{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quickdraw Data\n",
    "\n",
    "If machine learning is rocket science then data is your fuel! So before\n",
    "doing anything we will have a close look at the data available and spend\n",
    "some time bringing it into the \"right\" form (i.e.\n",
    "[tf.train.Example](https://www.tensorflow.org/versions/r1.0/api_docs/python/tf/train/Example)).\n",
    "\n",
    "That's why we start by spending quite a lot on this notebook, downloading\n",
    "the data, understanding it, and transforming it into the right format for\n",
    "Tensorflow.\n",
    "\n",
    "The data used in this workshop is taken from Google's quickdraw (click on\n",
    "the images to see loads of examples):\n",
    "\n",
    "https://quickdraw.withgoogle.com/data\n",
    "\n",
    "Table of contents:\n",
    "\n",
    "- [ 1 Get the data](#1-Get-the-data)\n",
    "- [ 2 Inspect the data](#2-Inspect-the-data)\n",
    "- [ 3 Rasterize](#3-Rasterize)\n",
    "- [ 4 tf.train.Example data format](#4-tf.train.Example-data-format)\n",
    "- [ 5 Create dataset](#5-Create-dataset)\n",
    "- [ 6 Prepare dataset for RNN – bonus!](#6-Prepare-dataset-for-RNN-%E2%80%93-bonus!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.4.1'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import base64, io, itertools, json, os, random, re, time\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from matplotlib import pyplot\n",
    "from PIL import Image, ImageDraw\n",
    "from IPython import display\n",
    "from six.moves.urllib import request\n",
    "from xml.dom import minidom\n",
    "\n",
    "%matplotlib inline\n",
    "# Always make sure you are using running the expected version.\n",
    "# There are considerable differences between versions...\n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 Get the data\n",
    "\n",
    "In this section we download a set of raw data files from the web."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "available: (309)\n",
      "The Eiffel Tower The Great Wall of China The Mona Lisa aircraft carrier airplane alarm clock ambulance angel animal migration ant anvil apple arm asparagus axe backpack banana bandage barn baseball bat baseball basket basketball bat bathtub beach bear beard bed bee belt bench bicycle binoculars bird birthday cake blackberry blueberry book boomerang bottlecap bowtie bracelet brain bread bridge broccoli broom bucket bulldozer bus bush butterfly cactus cake calculator calendar camel camera camouflage campfire candle cannon canoe car carrot castle cat ceiling fan cell phone cello chair chandelier church circle clarinet clock cloud coffee cup compass computer cookie cooler couch cow crab crayon crocodile crown cruise ship cup diamond dishwasher diving board dog dolphin donut door dragon dresser drill drums duck dumbbell ear elbow elephant envelope eraser eye eyeglasses face fan feather fence finger fire hydrant fireplace firetruck fish flamingo flashlight flip flops floor lamp flower flying saucer foot fork frog frying pan garden hose garden giraffe goatee golf club grapes grass guitar hamburger hammer hand harp hat headphones hedgehog helicopter helmet hexagon hockey puck hockey stick horse hospital hot air balloon hot dog hot tub hourglass house plant house hurricane ice cream jacket jail kangaroo key keyboard knee knife ladder lantern laptop leaf leg light bulb lighter lighthouse lightning line lion lipstick lobster lollipop mailbox map marker matches megaphone mermaid microphone microwave monkey moon mosquito motorbike mountain mouse moustache mouth mug mushroom nail necklace nose ocean octagon octopus onion oven owl paint can paintbrush palm tree panda pants paper clip parachute parrot passport peanut pear peas pencil penguin piano pickup truck picture frame pig pillow pineapple pizza pliers police car pond pool popsicle postcard potato power outlet purse rabbit raccoon radio rain rainbow rake remote control rhinoceros rifle river roller coaster rollerskates sailboat sandwich saw saxophone school bus scissors scorpion screwdriver sea turtle see saw shark sheep shoe shorts shovel sink skateboard skull skyscraper sleeping bag smiley face snail snake snorkel snowflake snowman soccer ball sock speedboat spider spoon spreadsheet square squiggle squirrel stairs star steak stereo stethoscope stitches stop sign stove strawberry streetlight string bean submarine suitcase sun swan sweater swing set sword syringe t-shirt table teapot teddy-bear telephone\n"
     ]
    }
   ],
   "source": [
    "# Retrieve list of classes.\n",
    "\n",
    "def list_bucket(bucket, regexp='.*'):\n",
    "    \"\"\"Returns a (filtered) list of Keys in specified GCE bucket.\"\"\"\n",
    "    keys = []\n",
    "    fh = request.urlopen('https://storage.googleapis.com/%s' % bucket)\n",
    "    content = minidom.parseString(fh.read())\n",
    "    for e in content.getElementsByTagName('Contents'):\n",
    "        key = e.getElementsByTagName('Key')[0].firstChild.data\n",
    "        if re.match(regexp, key):\n",
    "            keys.append(key)\n",
    "    return keys\n",
    "\n",
    "all_ndjsons = list_bucket('quickdraw_dataset', '.*ndjson$')\n",
    "print 'available: (%d)' % len(all_ndjsons)\n",
    "print ' '.join([key.split('/')[-1].split('.')[0] for key in all_ndjsons])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store all data locally in this directory.\n",
    "data_path = '../data'\n",
    "\n",
    "# Mini group of two animals.\n",
    "pets = ['cat', 'dog']\n",
    "\n",
    "# Somewhat larger group of zoo animals.\n",
    "zoo = ['elephant', 'giraffe', 'kangaroo', 'lion', 'monkey', 'panda',\n",
    "       'penguin', 'rhinoceros', 'tiger', 'zebra']\n",
    "\n",
    "# Even larger group of all animals.\n",
    "animals = ['bat', 'bird', 'butterfly', 'camel', 'cat', 'cow', 'crab',\n",
    "           'crocodile', 'dog', 'dolphin', 'duck', 'elephant', 'fish',\n",
    "           'frog', 'giraffe', 'hedgehog', 'horse', 'kangaroo', 'lion',\n",
    "           'lobster', 'monkey', 'mosquito', 'mouse', 'octopus', 'owl',\n",
    "           'panda', 'parrot', 'penguin', 'pig', 'rabbit', 'raccoon',\n",
    "           'rhinoceros', 'scorpion', 'sea turtle', 'shark', 'sheep',\n",
    "           'snail', 'spider', 'squirrel', 'teddy-bear', 'tiger',\n",
    "           'whale', 'zebra']\n",
    "\n",
    "# Create your own group -- the more classes you include the more challenging\n",
    "# the classification task will be...\n",
    "\n",
    "# Choose one of above groups for remainder of workshop.\n",
    "# Note: This will result in ~100MB of download per class.\n",
    "classes, classes_name = zoo, 'zoo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "10 classes:\n",
      "elephant 70.86 MB\n",
      "giraffe 58.27 MB\n",
      "kangaroo 96.06 MB\n",
      "lion 90.47 MB\n",
      "monkey 91.05 MB\n",
      "panda 97.04 MB\n",
      "penguin 137.90 MB\n",
      "rhinoceros 92.20 MB\n",
      "tiger 86.09 MB\n",
      "zebra 92.10 MB\n",
      "\n",
      "DONE :)\n"
     ]
    }
   ],
   "source": [
    "# Download above chosen group.\n",
    "\n",
    "def valid_ndjson(filename):\n",
    "    \"\"\"Checks presence + completeness of .ndjson file.\"\"\"\n",
    "    try:\n",
    "        json.loads(open(filename).readlines()[-1])\n",
    "        return True\n",
    "    except ValueError, IOError:\n",
    "        return False\n",
    "\n",
    "def retrieve(bucket, key, filename):\n",
    "    \"\"\"Returns a file specified by its Key from a GCE bucket.\"\"\"\n",
    "    url = 'https://storage.googleapis.com/%s/%s' % (bucket, key)\n",
    "    if not os.path.isfile(filename):\n",
    "        request.urlretrieve(url=url, filename=filename)\n",
    "    while not valid_ndjson(filename):\n",
    "        print '*** Corrupted download (%.2f MB), retrying...' % (os.path.getsize(filename) / 2.**20)\n",
    "        request.urlretrieve(url=url, filename=filename)\n",
    "\n",
    "if not os.path.exists(data_path):\n",
    "    os.mkdir(data_path)\n",
    "\n",
    "print '\\n%d classes:' % len(classes)\n",
    "\n",
    "for name in classes:\n",
    "    print name,\n",
    "    dst = '%s/%s.ndjson' % (data_path, name)\n",
    "    retrieve('quickdraw_dataset', 'full/simplified/%s.ndjson' % name, dst)\n",
    "    print '%.2f MB' % (os.path.getsize(dst) / 2.**20)\n",
    "\n",
    "print '\\nDONE :)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Inspect the data\n",
    "\n",
    "What is the format of the downloaded files?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "README.md    dataset_stroke   kangaroo.ndjson  penguin.ndjson\t  tiger.ndjson\r\n",
      "bat.ndjson   dog.ndjson       lion.ndjson      rhinoceros.ndjson  zebra.ndjson\r\n",
      "cat.ndjson   elephant.ndjson  monkey.ndjson    sea lion.ndjson\t  zoo_img\r\n",
      "dataset_img  giraffe.ndjson   panda.ndjson     sea turtle.ndjson  zoo_stroke\r\n"
     ]
    }
   ],
   "source": [
    "# So let's check out the downloaded files...\n",
    "!ls $data_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"word\":\"cat\",\"countrycode\":\"VE\",\"timestamp\":\"2017-03-02 23:25:10.07453 UTC\",\"recognized\":true,\"key_id\":\"5201136883597312\",\"drawing\":[[[130,113,99,109,76,64,55,48,48,51,59,86,133,154,170,203,214,217,215,208,186,176,162,157,132],[72,40,27,79,82,88,100,120,134,152,165,184,189,186,179,152,131,114,100,89,76,0,31,65,70]],[[76,28,7],[136,128,128]],[[76,23,0],[160,164,175]],[[87,52,37],[175,191,204]],[[174,220,246,251],[134,132,136,139]],[[175,255],[147,168]],[[171,208,215],[164,198,210]],[[130,110,108,111,130,139,139,119],[129,134,137,144,148,144,136,130]],[[107,106],[96,113]]]}\n",
      "{\"word\":\"cat\",\"countrycode\":\"BR\",\"timestamp\":\"2017-03-26 18:43:54.78083 UTC\",\"recognized\":true,\"key_id\":\"4647694628814848\",\"drawing\":[[[222,196,176,173,179,191,233,251,255,250,231,219],[31,32,43,60,72,79,79,69,54,35,27,27]],[[176,198,203],[42,0,26]],[[219,238,249,252,252],[29,11,5,16,43]],[[190,188,191,200,204,200],[44,45,49,51,43,41]],[[233,228,233,241,243,231],[44,48,53,53,46,43]],[[203,208,213,218,227,234],[63,69,...\n"
     ]
    }
   ],
   "source": [
    "# What is the NDJSON file format?\n",
    "# Seems to be one JSON dictionary per line...\n",
    "path = tf.gfile.Glob(os.path.join(data_path, '*.ndjson'))[1]\n",
    "print file(path).read()[:1000] + '...'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[u'word', u'countrycode', u'timestamp', u'recognized', u'key_id', u'drawing']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Parse single line.\n",
    "data_json = json.loads(file(path).readline())\n",
    "data_json.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                word   ->   cat\n",
      "         countrycode   ->   VE\n",
      "           timestamp   ->   2017-03-02 23:25:10.07453 UTC\n",
      "          recognized   ->   True\n",
      "              key_id   ->   5201136883597312\n"
     ]
    }
   ],
   "source": [
    "# So we have some meta information...\n",
    "for k, v in data_json.iteritems():\n",
    "    if k != 'drawing':\n",
    "        print '%20s   ->   %s' % (k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 25), (2, 3), (2, 3), (2, 3), (2, 4), (2, 2), (2, 3), (2, 8), (2, 2)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ...and the actual drawing.\n",
    "drawing = data_json['drawing']\n",
    "# The drawing consists of a series of strokes:\n",
    "[np.array(stroke).shape for stroke in drawing]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0aa7d717d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Draw the image -- the strokes all have have shape (2, n)\n",
    "# so the first index seems to be x/y coordinate:\n",
    "for stroke in drawing:\n",
    "    pyplot.plot(np.array(stroke[0]), -np.array(stroke[1]))\n",
    "# Would YOU recognize this drawing successfully?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading some \"elephant\"...\n",
      "CPU times: user 40 ms, sys: 180 ms, total: 220 ms\n",
      "Wall time: 43.8 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Some more code to load many sketches at once.\n",
    "# Let's ignore the difficult \"unrecognized\" sketches for now...\n",
    "# (i.e. unrecognized by the official quickdraw classifier)\n",
    "\n",
    "def convert(line):\n",
    "    \"\"\"Converts single line to JSON + converts 'drawing' to list of np.array.\"\"\"\n",
    "    d = json.loads(line)\n",
    "    d['drawing'] = [np.array(stroke) for stroke in d['drawing']]\n",
    "    return d\n",
    "\n",
    "def loaditer(name, unrecognized=False):\n",
    "    \"\"\"Returns iterable of drawings in specified file.\n",
    "\n",
    "    Args:\n",
    "      name: Name of the downloaded object (e.g. \"elephant\").\n",
    "      unrecognized: Whether to include drawings that were not recognized\n",
    "          by Google AI (i.e. the hard ones).\n",
    "    \"\"\"\n",
    "    for line in open('%s/%s.ndjson' % (data_path, name)):\n",
    "        d = convert(line)\n",
    "        if d['recognized'] or unrecognized:\n",
    "            yield d\n",
    "\n",
    "def loadn(name, n, unrecognized=False):\n",
    "    \"\"\"Returns list of drawings.\n",
    "\n",
    "    Args:\n",
    "      name: Name of the downloaded object (e.g. \"elephant\").\n",
    "      n: Number of drawings to load.\n",
    "      unrecognized: Whether to include drawings that were not recognized\n",
    "          by Google AI (i.e. the hard ones).\n",
    "    \"\"\"\n",
    "    it = loaditer(name, unrecognized=unrecognized)\n",
    "    return list(itertools.islice(it, 0, n))\n",
    "\n",
    "print 'loading some \"%s\"...' % classes[0]\n",
    "sample = loadn(classes[0], 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0adccceb50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Some more drawings...\n",
    "pyplot.figure(figsize=(10, 10))\n",
    "n = 3\n",
    "for x in range(n):\n",
    "    for y in range(n):\n",
    "        i = x * n + y\n",
    "        pyplot.subplot(n, n, i + 1)\n",
    "        for stroke in sample[i]['drawing']:\n",
    "            pyplot.plot(np.array(stroke[0]), -np.array(stroke[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Rasterize\n",
    "\n",
    "Idea: After converting the raw drawing data into rasterized images, we can\n",
    "use [MNIST](https://www.tensorflow.org/get_started/mnist/beginners)-like\n",
    "image processing to classify the drawings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting _derived/1_json_to_img.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile _derived/1_json_to_img.py\n",
    "# (Written into separate file for sharing between notebooks.)\n",
    "\n",
    "# Function that converts drawing (specified by individual strokes)\n",
    "# to a rendered black/white image.\n",
    "\n",
    "def json_to_img(drawing, img_sz=64, lw=3, maximize=True):\n",
    "    img = Image.new('L', (img_sz, img_sz))\n",
    "    draw = ImageDraw.Draw(img)\n",
    "    lines = np.array([\n",
    "        stroke[0:2, i:i+2]\n",
    "        for stroke in drawing['drawing']\n",
    "        for i in range(stroke.shape[1] - 1)\n",
    "    ], dtype=np.float32)\n",
    "    if maximize:\n",
    "        for i in range(2):\n",
    "            min_, max_ = lines[:,i,:].min() * 0.95, lines[:,i,:].max() * 1.05\n",
    "            lines[:,i,:] = (lines[:,i,:] - min_) / max(max_ - min_, 1)\n",
    "    else:\n",
    "        lines /= 1024\n",
    "    for line in lines:\n",
    "        draw.line(tuple(line.T.reshape((-1,)) * img_sz), fill='white', width=lw)\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0adcc73dd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# (Load code from previous cell -- make sure to have executed above cell first.)\n",
    "%run -i _derived/1_json_to_img.py\n",
    "\n",
    "# Show some examples.\n",
    "\n",
    "def showimg(img):\n",
    "    if isinstance(img, np.ndarray):\n",
    "        img = Image.fromarray(img, 'L')\n",
    "    b = io.BytesIO()\n",
    "    img.convert('RGB').save(b, format='png')\n",
    "    enc = base64.b64encode(b.getvalue()).decode('utf-8')\n",
    "    display.display(display.HTML(\n",
    "        '<img src=\"data:image/png;base64,%s\">' % enc))\n",
    "\n",
    "# Fetch some images + shuffle order.\n",
    "rows, cols = 10, 10\n",
    "n_per_class = rows * cols // len(classes) + 1\n",
    "drawings_matrix = [loadn(name, rows*cols) for name in classes]\n",
    "drawings_list = reduce(lambda x, y: x + y, drawings_matrix, [])\n",
    "drawings_list = np.random.permutation(drawings_list)\n",
    "\n",
    "# Create mosaic of rendered images.\n",
    "lw = 4\n",
    "img_sz = 64\n",
    "tableau = np.zeros((img_sz * rows, img_sz * cols), dtype=np.uint8)\n",
    "for y in range(rows):\n",
    "    for x in range(cols):\n",
    "        i = y * rows + x\n",
    "        img = json_to_img(drawings_list[i], img_sz=img_sz, lw=lw, maximize=True)\n",
    "        tableau[y*img_sz:(y+1)*img_sz, x*img_sz:(x+1)*img_sz] = np.asarray(img)\n",
    "\n",
    "showimg(tableau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 tf.train.Example data format\n",
    "\n",
    "Tensorflow's \"native\" format for data storage is the `tf.train.Example`\n",
    "[protocol buffer](https://en.wikipedia.org/wiki/Protocol_Buffers).\n",
    "\n",
    "In this section we briefly explore the API needed to access the data\n",
    "inside the `tf.train.Example` protocol buffer. It's **not necessary** to read\n",
    "through the\n",
    "[Python API documentation](https://developers.google.com/protocol-buffers/docs/pythontutorial)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Create a new (empty) instance.\n",
    "example = tf.train.Example()\n",
    "# (empty example will print nothing)\n",
    "print example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features {\n",
      "  feature {\n",
      "    key: \"adversaries\"\n",
      "    value {\n",
      "      bytes_list {\n",
      "        value: \"Alice\"\n",
      "        value: \"Bob\"\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  feature {\n",
      "    key: \"magic_numbers\"\n",
      "    value {\n",
      "      float_list {\n",
      "        value: 3.14159989357\n",
      "        value: 2.71830010414\n",
      "        value: 1.41419994831\n",
      "        value: 1.61800003052\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# An example contains a map from feature name to \"Feature\".\n",
    "# Every \"Feature\" contains a list of elements of the same\n",
    "# type, which is one of:\n",
    "# - bytes_list (similar to Python's \"str\")\n",
    "# - float_list (float number)\n",
    "# - int64_list (integer number)\n",
    "\n",
    "# These values can be accessed as follows (no need to understand\n",
    "# details):\n",
    "\n",
    "# Add float value \"3.1416\" to feature \"magic_numbers\"\n",
    "example.features.feature['magic_numbers'].float_list.value.append(3.1416)\n",
    "# Add some more values to the float list \"magic_numbers\".\n",
    "example.features.feature['magic_numbers'].float_list.value.extend([2.7183, 1.4142, 1.6180])\n",
    "\n",
    "### YOUR ACTION REQUIRED:\n",
    "# Create a second feature named \"adversaries\" and add the elements\n",
    "# \"Alice\" and \"Bob\".\n",
    "example.features.feature['adversaries'].bytes_list.value.extend(['Alice', 'Bob']) #example.features.feature['adversaries'].\n",
    "\n",
    "# This will now print a serialized representation of our protocol buffer\n",
    "# with features \"magic_numbers\" and \"adversaries\" set...\n",
    "print example\n",
    "\n",
    "# .. et voila : that's all you need to know about protocol buffers\n",
    "# for this workshop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5 Create dataset\n",
    "\n",
    "Now let's create a \"dataset\" of `tf.train.Example`\n",
    "[protocol buffers](https://developers.google.com/protocol-buffers/) (\"protos\").\n",
    "\n",
    "A single example contains all the information for a drawing (i.e. rasterized\n",
    "image, label, and meta information).\n",
    "\n",
    "A dataset consists of non-overlapping sets of examples that will be used for\n",
    "training and evaluation of the classifier (the \"test\" set will be used for the\n",
    "final evaluation). Because these files can quickly become very large, we\n",
    "\"shard\" them into multiple smaller files of equal size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elephant 126969 recognized 104986\n",
      "giraffe 127182 recognized 122396\n",
      "kangaroo 174470 recognized 152511\n",
      "lion 120949 recognized 98976\n",
      "monkey 127633 recognized 105650\n",
      "panda 113613 recognized 94814\n",
      "penguin 253791 recognized 231826\n",
      "rhinoceros 188484 recognized 166539\n",
      "tiger 121067 recognized 110177\n",
      "zebra 144608 recognized 127159\n"
     ]
    }
   ],
   "source": [
    "# Let's first check how many [recognized=True] examples we have in each class.\n",
    "# Depending on your choice of classes you could generate up to 200k examples...\n",
    "for name in classes:\n",
    "    print name, len(list(open('%s/%s.ndjson' % (data_path, name)))), 'recognized', len(list(loaditer(name)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper code to create sharded recordio files.\n",
    "# (No need to read through this.)\n",
    "\n",
    "# Well... Since you continue to read through this cell, I could as\n",
    "# well explain in more detail what it is about :-)\n",
    "# Because we work with large amounts of data, we will create \"sharded\"\n",
    "# files, that is, we split a single dataset into a number of files, like\n",
    "# train-00000-of-00005, ..., train-00004-of-00005 (if we're using 5 shards).\n",
    "# This way we have smaller individual files, and we can also easily access\n",
    "# e.g. 20% of all data, or have 5 threads reading through the data\n",
    "# simultaneously.\n",
    "\n",
    "# The code in this cell simply takes a list of iterators and then\n",
    "# randomly distributes the values returned by these iterators into sharded\n",
    "# datasets (e.g. a train/eval/test split).\n",
    "\n",
    "def rand_key(counts):\n",
    "    \"\"\"Returns a random key from \"counts\", using values as distribution.\"\"\"\n",
    "    r = random.randint(0, sum(counts.values()))\n",
    "    for key, count in counts.iteritems():\n",
    "        if r > count or count == 0:\n",
    "            r -= count\n",
    "        else:\n",
    "            counts[key] -= 1\n",
    "            return key\n",
    "\n",
    "def make_sharded_files(make_example, path, classes, iters, splits,\n",
    "                       shards=10, overwrite=False, report_dt=10):\n",
    "    \"\"\"Create sharded files from \"iters\".\n",
    "\n",
    "    Args:\n",
    "      make_example: Converts object returned by elements of \"iters\"\n",
    "          to tf.train.Example() proto.\n",
    "      path: Directory that will contain recordio files.\n",
    "      classes: Names of classes, will be written to \"labels.txt\".\n",
    "      splits: Dictionary mapping filename to number of examples (of\n",
    "          every class).\n",
    "      shards: Number of files to be created per split.\n",
    "      overwrite: Whether a pre-existing directory should be overwritten.\n",
    "      report_dt: Number of seconds between status updates (0=no updates).\n",
    "\n",
    "    Returns:\n",
    "      Total number of examples written to disk (this should be equal to\n",
    "      the number of classes times the sum of the number of examples of\n",
    "      all the splits).\n",
    "    \"\"\"\n",
    "    assert len(iters) == len(classes)\n",
    "    if not os.path.exists(path):\n",
    "        os.makedirs(path)\n",
    "    paths = {\n",
    "        split: ['%s/%s-%05d-of-%05d' % (path, split, i, shards)\n",
    "                for i in range(shards)]\n",
    "        for split in splits\n",
    "    }\n",
    "    assert overwrite or not os.path.exists(paths.values()[0][0])\n",
    "    writers = {\n",
    "        split: [tf.python_io.TFRecordWriter(ps[i]) for i in range(shards)]\n",
    "        for split, ps in paths.iteritems()\n",
    "    }\n",
    "    t0 = time.time()\n",
    "    n = sum(splits.values())\n",
    "    examples = 0\n",
    "    for i in range(n):\n",
    "        split = rand_key(splits)\n",
    "        writer = writers[split][splits[split] % shards]\n",
    "        for j in range(len(classes)):\n",
    "            example = make_example(j, iters[j].next())\n",
    "            writer.write(example.SerializeToString())\n",
    "            examples += 1\n",
    "        remaining = sum(splits.values())\n",
    "        if report_dt > 0 and time.time() - t0 > report_dt:\n",
    "            print 'processed %d/%d (%.2f%%)' % (i, n, 100. * i / n)\n",
    "            t0 = time.time()\n",
    "    for split in splits:\n",
    "        for writer in writers[split]:\n",
    "            writer.close()\n",
    "    with open('%s/labels.txt' % path, 'w') as f:\n",
    "        f.write('\\n'.join(classes))\n",
    "    return examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting _derived/1_make_example_img.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile _derived/1_make_example_img.py\n",
    "# (Written into separate file for sharing between notebooks.)\n",
    "\n",
    "# Convert drawing tf.train.Example proto.\n",
    "# Uses json_to_img() from previous cell to create raster image.\n",
    "\n",
    "def make_example_img(label, drawing):\n",
    "    example = tf.train.Example()\n",
    "    example.features.feature['label'].int64_list.value.append(label)\n",
    "    img_64 = np.asarray(json_to_img(drawing, img_sz=64, lw=4, maximize=True)).reshape(-1)\n",
    "    example.features.feature['img_64'].int64_list.value.extend(img_64)\n",
    "    example.features.feature['countrycode'].bytes_list.value.append(drawing['countrycode'].encode())\n",
    "    example.features.feature['recognized'].int64_list.value.append(drawing['recognized'])\n",
    "    example.features.feature['word'].bytes_list.value.append(drawing['word'].encode())\n",
    "    ts = drawing['timestamp']\n",
    "    ts = time.mktime(time.strptime(ts[:ts.index('.')], '%Y-%m-%d %H:%M:%S'))\n",
    "    example.features.feature['timestamp'].int64_list.value.append(long(ts))\n",
    "    example.features.feature['key_id'].int64_list.value.append(long(drawing['key_id']))\n",
    "    return example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processed 515/7000 (7.36%)\n",
      "processed 1041/7000 (14.87%)\n",
      "processed 1552/7000 (22.17%)\n",
      "processed 2029/7000 (28.99%)\n",
      "processed 2549/7000 (36.41%)\n",
      "processed 3051/7000 (43.59%)\n",
      "processed 3562/7000 (50.89%)\n",
      "processed 4085/7000 (58.36%)\n",
      "processed 4617/7000 (65.96%)\n",
      "processed 5135/7000 (73.36%)\n",
      "processed 5658/7000 (80.83%)\n",
      "processed 6183/7000 (88.33%)\n",
      "processed 6711/7000 (95.87%)\n",
      "stored data to \"../data/dataset_img\"\n",
      "generated 70000 examples in 135 seconds\n"
     ]
    }
   ],
   "source": [
    "# (Load code from previous cell -- make sure to have executed above cell first.)\n",
    "%run -i _derived/1_make_example_img.py\n",
    "\n",
    "# Create the (rasterized) dataset.\n",
    "\n",
    "path = '%s/dataset_img' % data_path\n",
    "t0 = time.time()\n",
    "n = make_sharded_files(\n",
    "    make_example=make_example_img,\n",
    "    path=path,\n",
    "    classes=classes,\n",
    "    iters=[loaditer(name) for name in classes],\n",
    "    # Note: We only generate few examples here so you won't be\n",
    "    # blocked for too long while waiting for this cell to finish.\n",
    "    # You can re-run the cell with larger values (don't forget to\n",
    "    # update \"path\" above) in the background to get a larger\n",
    "    # dataset...\n",
    "    splits=dict(train=5000, eval=1000, test=1000),\n",
    "    overwrite=True,\n",
    ")\n",
    "\n",
    "print 'stored data to \"%s\"' % path\n",
    "print 'generated %d examples in %d seconds' % (n, time.time() - t0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6 Prepare dataset for RNN – bonus!\n",
    "\n",
    "This section creates another dataset of example protos that contain the raw\n",
    "stroke data, suitable for usage with a recurrent neural network.\n",
    "\n",
    "Note that later notebooks will have a \"bonus\" section that uses this dataset,\n",
    "but the \"non-bonus\" parts can be worked through without executing below\n",
    "cells..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting _derived/1_json_to_stroke.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile _derived/1_json_to_stroke.py\n",
    "# (Written into separate file for sharing between notebooks.)\n",
    "\n",
    "# Convert stroke coordinates into normalized relative coordinates,\n",
    "# one single list, and add a \"third dimension\" that indicates when\n",
    "# a new stroke starts.\n",
    "\n",
    "def json_to_stroke(d):\n",
    "    norm = lambda x: (x - x.min()) / max(1, (x.max() - x.min()))\n",
    "    xy = np.concatenate([np.array(s, dtype=np.float32) for s in d['drawing']], axis=1)\n",
    "    z = np.zeros(xy.shape[1])\n",
    "    if len(d['drawing']) > 1:\n",
    "        z[np.cumsum(np.array(map(lambda x: x.shape[1], d['drawing'][:-1])))] = 1\n",
    "    dxy = np.diff(norm(xy))\n",
    "    return np.concatenate([dxy, z.reshape((1, -1))[:, 1:]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f0adc8fd690>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD8CAYAAACfF6SlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsnXd4VGXah+83vfcESE8g9BYIVaqAgCgoNizYxd7XXV1du7L72dau2AX72pCOSu+hB0IK6SG9J5PMZGbe749JYoBQM+XM5NzXlSszZ07mfQKZ33nO8z5FSClRUVFRUelaONnaABUVFRUV66OKv4qKikoXRBV/FRUVlS6IKv4qKioqXRBV/FVUVFS6IKr4q6ioqHRBVPFXUVFR6YKo4q+ioqLSBTGL+AshZggh0oQQmUKIxzt4/Q0hxL6Wr3QhRLU51lVRUVFROT9EZyt8hRDOQDowDSgAdgHXSikPn+L8+4FEKeWtp3vfkJAQGRsb2ynbVFRUVLoau3fvLpdShp7pPBczrDUSyJRSZgEIIb4F5gAdij9wLfDMmd40NjaW5ORkM5inoqKi0nUQQuSezXnmCPtEAPntnhe0HOvIqBggDvjTDOuqqKioqJwn1t7wnQf8T0pp6OhFIcQCIUSyECK5rKzMyqapqKiodB3MIf6FQFS755EtxzpiHvDNqd5ISrlISpkkpUwKDT1jyEpFRUVF5Twxh/jvAhKEEHFCCDdMAr/0xJOEEH2BQGCbGdZUUVFRUekEnRZ/KaUeuA9YDaQC30spDwkhnhdCzG536jzgW6kOEFBRUVGxOebI9kFKuQJYccKxp094/qw51lJRUVFR6Txqha+KiopKF8Qsnr/K6Wk2GDl0rJbduVU0NRvw83DB18MV3+O+mx77uLvg7CRsbbKKioqDo4q/BahramZvXjXJOZXsyqlib34VTc3Gs/55H3eX4y4IJ14k/NpfMNyPf93PwxUfD/UCoqKicnpU8TcDxTVNJOdWkpxTxa6cSlKLajFKcBLQP9yPeSOiGREbRFJsIP6ertQ2NVPfpKeu7auZuiY9tS3f2x+r0zZT2aAjt0JDXVMztU16dPozX0i83ZxPuqto/R4V5Mn80TH4erha4V+na9Gg1bN4ey7uLk7EhngTH+JNRIAnLs5qhFVFWajif44YjZLMsnp25fwl9gVVjQB4ujqTGB3AfRcmMCI2kMToQHzcT/4n9nB1Jsz3/G3Q6g0nXyRaLgwnHms9r1qjI79SQ22TnvJ6LZ9vyeGfF/djztBwhFDvEsxBfqWGO75M5khx3XHHXZ0F0UFexIV4t3z5EBviRXyID9383NV/fxWb0OnGbpYiKSlJKqm3z46sChZtzCI5t4qaxmYAQnzcGREbSFJsECNiA+nXww9XO/Dw9uVX8/SvKRwoqGFkXBDPzxlA3+5+tjbLrtmeVcE9X+1BbzDy9nXD6N/Dj+zyBnLKG8gqbyC7vJ6ccg3ZFQ3H3bl5uTkTE2y6Q4gL8Sa25Xt8iDeB3m42/I1U7BUhxG4pZdIZz1PF/8ykFNZw9Yfb8PNwZWLvUJJiAxkRG0RMsJfdem0Go+T75Hz+b9URapv0zB8dw8PTeuPvqYaCzpWvduTyzK+HiA724uMbk4gP9TnluUaj5FhNo+lCUF5PVssFIru8gfyqRgzGvz6P/p6ubReC9heGuBBvvDu4o1RRAVX8zUZhdSOXvbsFN2cnfr5nLGF+HrY2yaxUNeh4dU0aX+/MI9jbjcdn9mNuYgRO6obxWbFwZSofbshicp9Q3rw2Eb9O7KPo9EYKqjRkt1wM2n8V1TQdd26Yr7vpwhDqTWywd9vjqCAv3F2cO/trqdgxqvibgZrGZq76YCtFNU38ePdYenfrRKBe4aQU1vCvX1PYm1fNsOgAnp8zkIER/rY2S9FodHoGPbuGWYN68MY1Qy2aYdWoM5BTcfJFIae8gYoGXdt5TgIiAj2JC/EhLrhlnyHUh7hgbyICPdUssC7A2Yq/eu94CnR6I3cv2U12eQNf3DLSoYUfYGCEPz/eNZb/7SngPyuPMPudzVw/KoZHL+pNgJcae+6I/fk1GIySyxMjLC6qnm7O9OvhR78eJ+/N1Giaya5ov79gerwnt4p6rb7tPDdnJ6KDvYgNNt0lxIV4tz0O81U3nrsaqvh3gJSSx386wNajFbx21RDG9gqxtUlWwclJcHVSFNMHdOeNtel8uS2H5QeL+Pv0PlydFKWGgk5gT14VAInRATa1w9/LlaFeAQyNOt4OKSVl9doO9xc2ZpSdtPEcG+zNzIHduX9KgrV/BRUboIZ9OuCNtem8+UcGD0/tzYNTu+4H4fCxWp5ZmsKunCqGRPrz/JyBDImyrdApidu/2EVWeQN/PjrJ1qacMwajpKim8bgQ0qqUYpyEYMvjF9raPJVOoIZ9zpNVKcW8+UcGVw6P5IEpvWxtjk3pH+7H93eO4Zd9hby84giXvbeFeSOieGx6X4K6eBqilJI9edVM6Rtma1POC2cnQWSgF5GBXoxPMM3OyK3QUFLbdIafVHEUlJ+UbmW2Z1Xg5ebMwrmD1BgoIITg8sRI/nx0IrddEMf3yQVMfnU9i7fnHpeW2NXIqdBQ2aBjWEygrU0xG1UaHYHq/k6XQfX8O8DFSdhFsZY18fVw5alL+nP1iCie/jWFf/2Swne78nhu9kCGO5AAni17ck3x/mHRjvO7V2uaiQjwtLUZZkOnN/LAN3tpbDYQ4uNOiK8boT7uhPq6E9Lue4Cna5fcz1LFX+Wc6N3Nl2/uGM2yA0W8tDyVK97fylXDI/nHzL6E+Ljb2jyrsTuvCl93FxLCTl3QZW9UO5jnvymjjFWHikkI8yGjpI6yei3NhpPvVl2cBME+bqYLhE/7C4Mbob7uhPq4E+KAFwqziL8QYgbwJuAMfCyl/HcH51wNPAtIYL+U8jpzrK1ifYQQXDoknAv7hvHWnxl8ujmbVYeKeXRab24YHdMlmpjtya1iaHSAwwiB0SipaWwmwMtxKryXHyzCz8OF5Q+Mx83FCSkltY16yuq1lNVpKa//68v0XEd5vZb0kjrKz+JC0XrnYPo6/kIR6uOOv8IvFJ0WfyGEM/AuMA0oAHYJIZZKKQ+3OycBeAK4QEpZJYSwz10ylePwdnfhiZn9uGp4FM/9dohnfzvMt7vyeX7OQEbGBdnaPItR19RMekkd0wd0t7UpZqO2qRmjxGFqOrR6A2sPlzB9QHfcXEzOiBACfy9X/L1c6XWGO7a/LhRNlNXp2l0gjr9YpBWf+UJx6wVx3Dmxp0V+z85gDs9/JJAppcwCEEJ8C8wBDrc75w7gXSllFYCUstQM66oohF5hPnx560hWHyrmhWWpXP3hNi5PjOCJmX0drh0GmIq7jBKH2uuo1piaFQY6iOe/JbOcuiY9swb1OK+fP/5CcfpzpTTdNZXXayltvYOo01JWr2VvXhULVx6hbw8/JvYOPS9bLIU5xD8CyG/3vAAYdcI5vQGEEFswhYaelVKuMsPaKgpBCMGMgT2Y2DuMd9dlsmhjFr8fLuGX+y6g52kandkje/KqEAKG2ri4y5xUaUwtIhwl7LPsgCnkc4EVCjSFEAR4uRHg5UavE3q1NzUbmPPOFh79fh8rHhxPmK9ynCFrBWddgARgEnAt8JEQ4qRPjhBigRAiWQiRXFZWZiXTVMyJp5szf5veh+UPjKNOq2flwSJbm2R2dudWkRDm06kmbkqj1fN3hLBPa8hnWv+/Qj62wsPVmbevS6Req+eR7/ZjVFB6tDk8/0Igqt3zyJZj7SkAdkgpm4FsIUQ6povBrvYnSSkXAYvAVOFrBtvOGSGgTqtnxn83EurrTpivh2kjp/XLx50wP9NjX3cXtRbgFCR086Vvd1+2Hq3gvgsdp0raaJTszati1uDzCycolVbP3xGyfdpCPoOVsSfTu5svz1w6gCd+OsiHG7O4e5Iy4v/mEP9dQIIQIg6T6M8DTszk+QWTx/+ZECIEUxgoywxrm51rRkTR1GykrCVmd7S0/JQpYu4uTm0XhbC2i4PH8c9bMgJs7YHYgrE9Q1iyI5emZgMero7RZjirvJ7aJj2JDpTfD44V819+oBhfDxfG9VJOjH3eiCg2Z5bz6po0Lh7UnZhgb1ub1Hnxl1LqhRD3AasxxfM/lVIeEkI8DyRLKZe2vHaREOIwYAAek1JWdHZtS9C3ux8L5w467ljrhk5ZnWmXv7Tle2vKWGldE9nlDezMrqSq5UN0IgFeru0uEO7tLhoex91VBHi5OszdxNiewXy6JZu9edWM6Rlsa3PMwm4HLO4CU46/ENj9XGed3sjaw8VM699NUQ6XEIK7J/Zk+YEiUovqHEP8AaSUK4AVJxx7ut1jCTzS8mV3tN/QSThDa2ed3khFg5bS2uMvEK0XibI6Lbvzqiit1aLtYBB7iI87d4yP44bRMXY/rWlkfBBOArYdLXcY8d+TW02AlyvxIbb/8JqTKk0z/p6udt/vf0tmObWdyPKxJD38TZu9xTWNNrbEhH2riwJxc3Gih78nPfxPXyYvpaReq//rLqLla11aKQtXHuGDDUe5fXw8N46JsVtvzM/DlUGRAWw9WmGfV/0O2JNXRWKU4xR3teIofX3+OFKCl5sz4xKU14Y9yNsNN2enk6ay2QpV/G2EEAJfD1d8PVyPS4W8dVwce/KqePuPDF5ZncaijVncNi6Om8bG2uV83THxwXy8KQuNTo+Xm33/udVomskorWf2kHBbm2J2HKW6N8DTDa3eiBI71Qsh6O7voRjxV05QTKWNYdGBfHbLSJbedwEjYoN4fW064/7zJ6+vTadaozvzGyiIsT2D0Rslu3KqbG1Kp9mbb/odHKm4q5UqjY4AO3QuTmRQpD8Go+RwUa2tTemQHv4eFKvir3ImBkcG8PFNSSy7fxwX9AzhrT8yGPefdbyy+giVDfZxEUiKDcTVWbD1aLmtTek0e/KqcRI45ECbqoZmhwj7DI40zZ0+WFBjY0s6poe/B8cUEvNXxd8OGBjhzwfzh7PqofFM7BPKe+uPMu4/f7JwZSrl9Vpbm3davNxcSIwKZNtRRSZ3nRN7cqvo093P7jfiO6Jao3OIAq/ufh6E+LhzQKHi393fk5LaJkUUe6nib0f07e7Hu9cNY81DE5jWvxsfbcxizjtbjpvFqkTG9AwmpbCGmsaO02DtAYNRsi+/muExjuf16/RGGnQGh8jxF0IwONKfg4XVtjalQ3r4e9BskFQo4M5dFX87JKGbL2/OS+TD+UkUVjey7MAxW5t0Wsb0DMYoYWd2pa1NOW8ySuuo1+odLr8foLrRsfr6DIrwJ7O0ngat3tamnERrumeRAkI/qvjbMVP7hZEQ5sPHm7KRSkxvaCExOgB3Fye7jvu3Fnc54mavI/X1AVPc3yhR5KZvawq4EjJ+VPG3Y4QQ3DoujsNFtWzPUq5X7e7izIjYILuO++/JrSbY243oIC9bm2J2qhocp68PmDx/QJFx/0Bv091VRb0a9lHpJJcnRhDk7cYnmxXZKqmNMT2DOVJcR4XCN6hPxd68KhKjAx2m9UZ7qhtbPX/HCPuE+XnQ3c+DgwXKi/vnVWoAiAy0/axkVfztHA9XZ24YFc0fR0rJKqu3tTmnpLW9g5LvUE5FZYOOrPIGhwz5AG21I44i/mDK91ei559eXAdA3+6nbxNjDVTxdwBuGBODq5MTn23JsbUpp2RwhD8+7i52Gfffm9fazM3xMn2AtmaEjhL2AdPfW1Z5A7VNysowSyupI9DLlVBfd1ubooq/IxDm68HsoeH8b3eBYiuAXZydGBkXxLYs+4v778mrwsVJMDjSUcVfh5uzE15ujtF2G0yeP0BKobK8/yPFdfTu5quI8KEq/g7CbePiaGw28PXOPFubckoiAz3JKW9Ab1B2XcKJ7M6ton+4H54OJI7tqdE0O1Qrcfhr01dJlb5SStKL6xQR8gFV/B2Gfj38uKBXMF9szVFk0VejzsDS/ce4qH93XJzt589ObzCyP7/GIfP7W6nS6Bwq3g8Q7ONORIAnBxTk+RdUNdKgM9BbFX8Vc3P7uHhKarWsUODc3F/2FVKtaeaWC2Jtbco5caS4jsZmA4kOGu8HU8zfUXL82zM40l9Rnn96iXI2e8FM4i+EmCGESBNCZAohHu/g9ZuFEGVCiH0tX7ebY12V45nYO5QAL1c2ppfZ2pTjkFLy2ZZsBoT7MTIuyNbmnBN78hy3uKuVao3OIVo7nMjgyADyKjWK2Qc70pLp0/sMA6GsRafFXwjhDLwLzAT6A9cKIfp3cOp3UsqhLV8fd3ZdlZNp0huoaWwmOlhZhUhbMitIL6nnlgvi7C6uvCe3ijBfUwjBUanWOEZHzxNp6/CpkNBPWnEdEQGeihnOZA7PfySQKaXMklLqgG+BOWZ4X5VzJKOkHimVc1vZyqdbsgnxcePSIcobrXcm9uRVM8xBi7vAdFdWrWnG3wE9/4Hhyqr0TS+po4+CPpvmEP8IIL/d84KWYydyhRDigBDif0KIKDOsq3ICaSXKuq0EyCqr588jpdwwOgZ3F/vKlimr05JXqXHokI9GZ0BnMDqk5+/v5UpssJci4v7NBiNHy+oV9dm01obvb0CslHIwsBb4oqOThBALhBDJQojksjJlxa3tgbTiOjxcnYgJVs5w8S+25uDm7MT1o2Jsbco50xrvH+aAbZxbqdK09vVxPM8fYFBkgCLCPtnlDTQbpKLuys0h/oVAe08+suVYG1LKCilla1OXj4HhHb2RlHKRlDJJSpkUGhpqBtO6FmnFdSSE+eKskOHiNY3N/LC7gEuHhCuiovFc2ZNXhauzYEBL+MARcbSOnicyOMKfwupGmw89at3sdbSwzy4gQQgRJ4RwA+YBS9ufIIRoH+ydDaSaYV2VE0grqVPUbeUPyflodAa7S+9sZU9uFQMj/PFwta9w1bnQJv4OML+3IwYpZNM3rbgWZydBfKhy7so7PY9OSqkXQtwHrAacgU+llIeEEM8DyVLKpcADQojZgB6oBG7u7Loqx1PZoKOsTquY20qDUfL51hxGxgUxMML+PGed3siBghpuGG1/4apzoS3s423fnr/RKKlr0lOl0VGl0VGtaaZKo6OwyjQ05WBBDZP7hNnMvrTieuJDvBW172WWYaRSyhXAihOOPd3u8RPAE+ZYS6Vj0lpziBUi/msPl1BQ1chTs/rZ2pTzIrWoFq3e6NCVvaDMds46vZFqjY6qFgE//nEzVQ2m59UtQl+laaamsRnDKebiOgnw87Dt3OW0klrF9YZyvEnUXZS0YtPUIqV4/p9uySYy0JNp/bvb2pTzonVylyNv9gJUtwxyCfC0rud/6FgNS/cdo6im6ThPvVrTTP1pxi+6uzgR6OVGgJcrgV5u9O3u1/a49XugtysBXm6mx16u+Hm44mTDfbAGrZ78ykauHq6sJEdV/B2EtJI6ArxcCVPAxmpKYQ07syt58uJ+itl8Plf25FUR7u/RNnbPUanSNOPt5oybi+UT/5qaDSw/UMSSHbnszavGzcWJcH8PArzcCPFxIyHMp0W0XQnwNn0/TtS93OyyuV5rWwclbfaCKv4OQ5qCWsV+tiUHLzdnrh6hLE/nXNibV02iA+f3t1Kt0Vk80yenvIGvduTyw+4CqjXNxId6869L+nPlsEiHLC47EVX8VSyGlJL0knrmDuuots66lNVp+W3/MeaNjMLfTjNIimuaKKxu5LZxcbY2xeJUNza3zZU1J3qDkd9TS/lqRy6bMspxcRJcNKAbN4yKYUzPYEU4KdbiSHEdnq7ORAUqq+2KKv4OQGF1I/VavSI8i6925KIzGLl5bKytTTlv/irucnzPv0qjM2t1b3FNE9/uyuPbnfkU1zYR7u/Bo9N6c82IKML8PMy2jj1huiv3sem+Q0eo4u8AtGb69LFxjr9Wb2DJ9jwm9wklPtTHprZ0ht25Vbi7ONG/h5+tTbE41ZrmTjetMxolW46W89X2PNamlmCUkgkJobxw2UAm9wm1q/kNliC9pI4L+9ouzfRUqOLvABxRSJrnsv1FlNdrudWOwyVNzQZ+3VfIBb1CrLIJams64/lXNej43+4Cvt6ZR3Z5A0Hebtw+Po7rR8YorrOsrSiv11Jer6NPd+U5Eqr4OwDpJXWE+3vgZ8NWsVJKPt2STUKYD+N6hdjMjs7yfXI+5fU67pwQb2tTLI7RKKlpbD6nvj5SSvbmV7Nkey7LDhSh0xtJignkwSkJzBzUXVFFTEogXSF35R2hir8DkFZs+1axu3KqOHSslpcvH2S3m3nNBiMfbshieEyg3Q2dOR9qm5qR8uz6+jRo9fy67xhLtudyuKgWbzdnrk6K5PpRMfTrAuGx80WJPX1aUcXfzmltFTvJhqXrAJ9uzibAy5XLE22fcXS+/Lb/GIXVjTw3e4DdXsDOhda+PssOHKOiQUtMkDfRwV7EBHvRzdcDJydBekkdS7bn8tOeQuq1evp29+XFywZyWWIEPu6qfJyJtOI6grxNdQxKQ/3fs3NaW8X26W67Ddb8Sg1rDhdz58SedlmEA6YQyPvrj9Knm68iN+csQXd/D6YP6EZqUR0fbMg6rj2Cu4sTob7uFFQ14ubsxKzBPbhhdLRDD7axBGkldfRRSP3Niajib+ekFpnaOvTpZrtb7y+35SCEYL4dN0H7PbWEjNJ6/nvNUMWl5FkKD1dnPpyfBJjuII9VN5JboSG3UkNeRQOF1Y3MHx3DVUlRBNl54zdbYDRK0kvquDpJmcWOqvjbOUv3HSPU152Ebrbx/Bu0er7dlc/Mgd0Jt9M5t1JK3lt/lKggTy4ZbH+jJs2Bq7NpCJCSBgHZO4XVjWh0BkXG+8F6k7xULEB+pYY/00qZNyIKVxvlUv+4p4C6Jj23XGC/6Z3bsyrZl1/Nggk9u3xOuor5UPJmL6jib9d8vTMPAVw7Mtom6xuNks+35DAkKoBh0fbb/fK99ZmE+Lhz1fBIW5ui4kC0dtpV0oCl9qjib6do9Qa+25XP1H7dbBZuWZtaQlZ5A7deEKvIDa2z4WBBDZsyyrltXJxDT+xSsT5pJfVEBnoqNivKLOIvhJghhEgTQmQKIR4/zXlXCCGkECLJHOt2ZValFFPZoGP+GNtssjZo9Tz/22F6hflw8SD7jZO/vyETXw8Xbhhtm7snFcclrbhWMfM1OqLT4i+EcAbeBWYC/YFrhRD9OzjPF3gQ2NHZNVVg8bZcYoO9uKCnbappX1+bTmF1I/+eO8hm+w2d5WhZPStTipk/OgZfG1ZHqzgeOr2RrLIGxYZ8wDye/0ggU0qZJaXUAd8Cczo47wXgP0CTGdbs0hw+VktybhU3jI6xSVri/vxqPtuSzfWjokmKtd9K2A83HMXN2cmuexGpKJOs8nr0RqnYzV4wj/hHAPntnhe0HGtDCDEMiJJSLjfDel2eJTtycXdx4kobbFA2G4w8/tNBQnzc+cfMvlZf31wU1TTy895CrhkRRYiP7aefqTgWaQrP9AEr5PkLIZyA14Gbz+LcBcACgOhoNQbbEXVNzfyyt5DZQ8ItPoGpIz7ZnE1qUS0f3DDMpo3kOsvHm7IxSrhjvOM3cFOxPmnFdbg4CeJDlNva3ByefyHQvoQtsuVYK77AQGC9ECIHGA0s7WjTV0q5SEqZJKVMCg0NNYNpjsfPewvR6Aw22ejNrWjgv7+nM61/N6YPsM/B7GBqRfzNzjzmDAknKkhtPaxiftKK6+gZ6qPotuDmsGwXkCCEiBNCuAHzgKWtL0opa6SUIVLKWCllLLAdmC2lTDbD2l0KKSWLt+UyONKfwZHWzauXUvLULym4ODnx/Bz7bnz2+dYcNDoDd03qaWtTVByUtJI6m8/XOBOdFn8ppR64D1gNpALfSykPCSGeF0LM7uz7q/zFjuxKMkrrucEGPXR+3lvIpoxy/j6jDz387bONA5hSVD/fmsO0/t0UnYmhYr/Ua/UUVDUqOs0TzBTzl1KuAFaccOzpU5w7yRxrdkWWbM/F39OVSweHW3XdygYdLyw7TGJ0ANePst/mbQDf7MyjprGZu1WvX8VCpJe0TNZTuHOh3ICUynGU1jWxKqWYq4ZHWr1t8ovLD1PXpOffcwfjbMcdL7V6Ax9tymJ0fBDDoh1/OLuKbYgI8OT5OQMYGqXslieq+NsJ3+3MR2+UXG/lkM+mjDJ+2lPIXRN7Kjpt7Wz4eU8hJbVa7pnUy9amqDgw3fw8uHFMLKG+yk4hVsXfDtAbjHy9M4/xCSHEhViv5W6jzsCTP6cQF+LNfRfat2AajJIPN2YxMMKP8Qn2O2NYRcVcqOJvB/x5pJSimiarb/S++UcGeZUaXr58kN03PVuZUkR2eQP3TOpl15lKKirmQhV/O2Dx9lx6+HswxYrjBQ8dq+GjTVlcnRTJmJ7BVlvXEkhpGtEYH+Jt1/UJKirmRBV/hZNd3sCmjHKuHRlttUEjBqPkiZ8OEujlyj8v7meVNS3JxoxyDh2r5a6JPe16w1pFxZyo4q9wvtqei4uTYN4I680B/XxrDgcKanj60gE2aSFhbt5bl0kPfw8uS4w488kqKl0EVfwVTFOzgR92FzB9YHfC/DyssmZBlYbX1qQxqU8olzrAPNvduVXsyK7k9vHxii61V1GxNsocMdNFkFJSWqclq6yBhG4+J3WX/G3/MWoam5lvpY1eKSVP/3oIKeHFywY6xMbo++szCfBy5dqR1rtzUlHpCJ3eSINWT4NOT4PWQL1WT4NWT7CPGwPC/a1ujyr+VkBKybGaJjJK6sgsrSejpJ6M0joySuupa9ID4OXmzN0Te3L7+Pi2Iq4l23NJCPNhVJx1euYvO1DEn0dKeWpWPyID7b/hWVpxHb+nlvLQ1AS83NQ/dZVzQ6s3oGkVaZ1JqBu0Bhq0+jbhbtAZWo7rqW95rf259Vo9mhax1xmMHa7j5uzE7n9NtfpAIfUTYUaMRklBVWObsGeU1JNZahL8Bp2h7bwQHzd6hflw2dAIeoX5EBXkyXe78nltbTpf78zjsel9iA/1YX9BDc/Ntk4TtRpNM8/9dohBEf7cPDbW4utZg/fXZ+Ll5uwwv4/KqZFSojMYjxNnje4vQa7X6tG0iHV9m1jr0WgNNOjaiXnL8wa06nVYAAAgAElEQVStnmaDPKu1XZwE3u4u+Li74O3ujJeb6XGor3vbcdMxZ7zdXUxfbqZz8ys1/OvXQyTnVjG5j/Wy+UAV//NCbzCSV6kho7S+xZM3if3Rsnqamv+6unfzcychzJerkqJI6OZDQpgvvcJ8CPI+eRP1wr7d2JFVwYvLU3nk+/1txy8fZp1NyoUrU6nSNPP5LSOtllVkST7bks0v+46xYEK8Q2xaOxpSSrStYZB2glt/wvNWj1pzgkC396hbj+uNZyfWrs7iOAFuFehuvh54uTu3iHiLmLs549Um7CYBbxV37xaxd3N2Om8HrVFn4LnfDrMzu1IVfyVysKCGP4+UktHixWeVNRx3CxcR4EmvMB/GxAeT0M2HXi0i7+95brdxo+KD+fXeC/hyWw7P/nYYgL99v58nLu5n0cre7VkVfLsrnzsnxDMwwvqxR3Pz7rpMXlmdxvQB3Xj0ot62NschaBXrVm+5NRTS5j2fMhTyV4y7/TGNznDWYu3m7HScR+3t7oyvhwvd/TzaBPkvj9q5nRf+l7h7t/ysl7sz7i7KKVj0dHNmcKQ/O7IqrL62Kv5n4Lf9x3jk+33ojZKoQC8SwnyY2CeUhDBfEsJ86Bnmg4+7+f4ZnZxE24di1qAerE8rZdrrG5g/JoYHpySY3Yttajbwz58OEhXkyUNT7VsopZS8tiadd9ZlMmdoOK9dNcQh7mLOByklTc3GM3vUWj31J8SzG9qFSxraCbrhbMXaxekkEfb1cKGHv0e7MMgJIu32l4C3CrzJM3dx+CytUfHBfLQxi0adwapNG1XxPw1fbM3h2d8OMSImiA/nDyewg3CNuTEaJV/tyGN4TCDvXj+M0rom3libzhdbc/hxdwEPTEngxjGxZvtAvLcuk6zyBr68daTVu4WaEyklLyxL5dMt2cwbEcVLlw+yq4KuVrGuP8E7Pp1HrWkXv27/eutr5yLWJwquv6crEQEebc/bh0dOFb9ufc3RxdrcjIwL4v31R9mTV8UFvazXd0oV/w6QUvL62nTe/jOTaf278fa1iVbrbbP1aAXZ5Q08OCUBgDBfDxbOHcxNY2N5aXkqLy5PZcn2XB6f2ZfpA7p3ejN4Q3oZgV6uDI+xwxbHX30FTz6JzMujOrg75aOv4+Y7buGZS/tbfJNcSkljs+Evj7pNgNt51C2vldY18dWOPLOt7d4i1l4tYu3j7kKAlxuRgR141O0EvfVn2uLXbqbnrl307kgpJMUE4iRMw5rsTvyFEDOANwFn4GMp5b9PeP0u4F7AANQDC6SUh82xtrkxGE3jCr/ZmcfVSZG8fPkgq4YOFm/PIcjbjZmDju9B07e7H4tvG8X6tFJeXpHKXUv2MDI2iCdn9WNIJ/qGPzmrP9cs2saLyw+zcO7gzppvPb76ChYsAI0GAQSWF/Ha2ndxmZeIEANOOl1K2eZJN5yrR31CRkhrhshZOtbnxeQ+odwwOoYgb7d2oRFVrB0RXw9XBoRbP+7fafEXQjgD7wLTgAJglxBi6Qni/rWU8oOW82cDrwMzOru2uWlqNvDgt3tZfaiEeyb15LHpfaxa6FRU08jawyUsmNDzlJtSk/qEMa5XCN8l5/PG2nTmvLuFy4aG89iMvkQEnPt4xZFxQdw5oScfbDjKhX27Ma1/t87+GtbhySdBoznukKu2ifIH/8Z9DfHHxa9bxVuepVh7uDodJ7je7s4EebsRFeTV5i3/5VmfnAHS+tzb3YU9eVXc8tku7p3ck3snn74ttsEoWXu4hE82Z7MurYz9BTVcPyqa+WNiCPO1ToW3im0YFRfEl9tz0eoNVtuQNofnPxLIlFJmAQghvgXmAG3iL6WsbXe+N2BBn+n8qG1q5o4vktmRXcnTl/Tn1nFxVrfhmx15SOD6UdGnPc/F2YnrR8Uwe0g4768/ysebs1mZUszt4+O4e1Kvc96AfmRabzakl/H4jwdIjJ5wUqWxIsnrOIwSVFGC0WiqpYgJ9moX8jCFQ7xaH7t1kBHSIvbm2ito1Bl45tdDxId4c/+FCWcVOpw7LJLLEyPYnlXJJ5uzeWddJh9sOMqlQ8K5bVycTSpBVSzPyLggPt6czf78GkZaqajTHOIfAeS3e14AjDrxJCHEvcAjgBtwoRnWNRuldU3c9OkuMkrqeHPeUOYMtX4DsGaDkW925TO5TxhRQWdXXevr4crfZ/TlulHRvLI6jXfXHeW7Xfk8Mq0PVydFnnW4ys3FiTfnDeWStzfz+I8H+ejG4cpv7RAdDbm5Jx12ionm+7vG2MCgk2mdh/DtgtHntGckhGBMz2DG9Awmp7yBz7Zk88PuAn7aU8jo+CBuGxfPlL5hONnRhrbK6RkRaxL8ndkVVhN/qwUPpZTvSil7Av8AnuroHCHEAiFEshAiuayszCp25VY0cOX728gpb+Djm5JsIvwAaw6VUFanPa8+PpGBXrw5L5Ff7r2A2GBv/vnzQS5+axMb0s/+37B3N1/+MaMvv6eW8N2u/DP/gK156SXwOuEi6eVlOq4ADh+r5aNNWVyTFMXo+POfhxAb4s1zcway7YkpPDGzL3kVGu74MpkLX1vPF1tzaNDqzWi1iq0I9Hajb3dfdmRXWm1NIc82EHqqNxBiDPCslHJ6y/MnAKSUC09xvhNQJaU87f1rUlKSTE5O7pRtZyKlsIabP9uJwSj59OYRJNpwqPe8RdsoqGpkw2OTOxV2kFKyKqWYhSuPkFepYULvUJ68uN9Zzd81GiXzP93B3rxq7p3ci+ggL2KCvYgJ8sbfy7p9R86Klmwf8vJMdwIvvQTXX29rqzAYJXPf20JhdSO/PzLRrLUZzQYjq1KK+WRzNvvyq/HzcOHakdHcNDaW8PPY81FRDk//msL/dhew/5mLOrWpL4TYLaVMOuN5ZhB/FyAdmAIUAruA66SUh9qdkyClzGh5fCnwzJmMs7T4pxTWMG/Rdvw8XPjytlH0CvOx2FpnIqOkjmlvbOQfM/py96SeZnlPrd7A4m25vPVHBvVaPdeMiOaRab3POFS6qKaR+Z/sJLO0/rjj/p6uxAR7HXdBiA42Pe7m66GGINrx2ZZsnvvtMG9dm8jsIeEWW2d3bhWfbs5mZUoRQgguHdyDhXMH23W9Rldm+YEi7v16Dz/fM7ZTjujZin+nY/5SSr0Q4j5gNaZUz0+llIeEEM8DyVLKpcB9QoipQDNQBdzU2XU7y9rDJdRr9ax+eMJ5ZcmYk6925OHm7MTVSZFme093F2duHx/PFcMiefOPDJZsz2XpvkLumdyL28bFnTIG3cPfk98fmUiDVk9epYbcCg15lQ0t3zUcLKxhZUrxcQVE7i5ORAV5ERPkZbogBHkRE2y6OEQGeiqqnN7SFFY38spq68xDGB4TyPCYQAqqNHy2JYdPNmfTt4cfd000jwOhYl1GxJkEf2d2pVWiEGbJ85dSrgBWnHDs6XaPHzTHOuakte+Ot429pAatnh93FzBrcA+CLZBlE+jtxrOzB3DjmBgWrjzCK6vT+Gp7Lo/N6MOcIRGn9Ni93V3o18OPfj38TnpNbzByrLqJ3HYXhdwK0+NtWRVo2nUwFQLC/T2JDvJiztBw5o08fSaTPSOl5OlfUpASXphjvXkIkYFe/OuS/mSW1rNoYxbzR8fgbcaWIyrWIczXg/gQb3ZkV3KnFS7gXfYvJNDbJP6VDTqbdn38dd8x6rR6bhhtWVGMD/XhoxuT2Ha0gpdWHObh7/bz2ZYcnprV/5yzC1ycnYgONnn54xOOf01KSXm9ru1uIbdCw5bMcrZlVRDk7ebQ4r8ypZg/WuYhnG3Gljl5cGoCc9/bypLtuVYRDxXzMyo+iGUHijAYpcXbk3TZUsHAFsGv0jTbzAYpJYu359Kvhx/DrLTZPKZnMEvvHcdrVw2htFbL1R9u467Fu8kpbzDL+wshCPV1Z3hMEHOHRXLruDjK6rV083Pn2dknV946CjWNzTyz9BADI/xsNj9gWHQgE3qH8uHGLDQ6NQvIHhkZF0Rdk57Uotozn9xJVPFv0NnMhj151aQW1TJ/dIxV8+qdnARXDI9k3d8m8ci03mzMKGPaGxt4/rfDVGvM9+9hNEoe/X4fhVWNvHf9sDNuNtsz/1l1hIp6Lf+eO9imnUQfnJJAZYOOxdtOroFQUT6j4kxpwTutkPLZZcW/daBKlRnF7lxZsj0XX3cX5gy1XEbI6fB0c+aBKQms/9sk5iZG8tnWbCa+sp5PNmej03c8cu5ceH/DUX5PLeXJWf0YHmOdwhVbsCunkq935HHrBXE2n4cwPMbk/S9SvX+7JDzAk8hAT1X8LUlAS966rcS/ol7L8gNFzB0WYfPNuTA/D/5z5WBWPDCeQRH+vLDsMBe9sYHVh4o531TgzRnlvLYmjdlDwh16jKJWb+CJnw4SEeDJw9OUMQ/hwSkJVDToWLJd9f7tEV8PVxqbDWc+sZN0WfH3cXfB1VnYLOb/fXIBOoORG86jotdS9Ovhx+LbRvLZzSNwcXbizsW7uWbRdg4W1JzT+xyrbuSBb/fSM9SHhXMHKb9VRCf4cEMWmaX1vHjZQJtfxFsZHhPI+IQQPtygev/2hsEoySqrJ8EKdUddVvyFEAR4udkk5m8wSr7emcvo+CASup258taaCCGY3DeMVQ+O54XLBnK0tJ5L39nMI9/t41h14xl/Xqs3cPdXe9DpjXwwf7hiBNESHC2r550/M7l0SDiT+1p3/uqZeGiq6v3bIwVVGrR6IwndVPG3KEFebjYJ+2xMLyO/spH5o2OtvvbZ4uLsxPzRMax7bBJ3T+rJsoNFTH51Pa+tSaP+NP1kXlh2mP351bx61WB6htquatrSGI2SJ346iIerE09f0t/W5pzE8JggxieEqLF/O6O1st4aHQe6tPgHeLlS1WD9sM/i7bmE+rpz0QDl987383DlHzP68scjE5k+oDtv/5nJpFfW883OvJPGBP60p4Al2/O4c0I8MwZatrrV1vywO5+d2ZU8OaufYrOYHpqaQHm9jq+2m2+KmIplyWgV/1DLRwS6tPgHeVvf88+v1LAurZRrR0TZ1USmqCAv3ro2kZ/vGUtMsBdP/HSQWW9tYmNL59DUolr++fNBRscH8dj0Pja21rKU1Wl5aXkqo+KCuDopytbmnJJW7//DjUdV799OyCipJ8zX3SqNFO1HfSxAgA3CPl/vzMNJCK49w8AWpZIYHcj/7hrDe9cPo0Gn58ZPdzL3vS3MfHMT/p6uvH3tMJvmuVuD55cdpqnZyMt2sJn94BTV+7cnMsvqrdZk0rE/pWcgyNuVKk3zeacznitavYHvduUztV8YPfztt/2uEIKLB/Xg90cm8sTMvuzJqwZMhXMK18JOs+5IKb/tP8Z9F/ayiz2NpNi/vP9GneXTB1XOHyklR0utk+kDXVz8A73cMBgltU3WuSVeebCYygadojd6zwV3F2f07eL+GaX1THplPe+uy6TJCnnK1qZBq+epX1LoFeZjV50z27z/HWrmj5Iprm2iXqtXPX9r0NriwZwtDU7Hku25xIV4M7bn+U92UhLtC7myF17MmocnMDo+mFdWpzHltQ38uq8Qo1Fx45rPmzfWplNY3cjCuYNwc7Gfj05SbBDjeoXwwQbV+1cyGSWtmT7WSf+2n79gC9C+s6elOXysluTcKq4fFe0Qg086KuTqGerDxzcl8fUdo/D3dOXBb/dx+ftbSc6x3mg6S5FSWMOnW7K5blR027xVe+LBqar3r3RaM32skeMPXV382zx/y6d7LtmRi4erE1cNV252yNlypkKusT1D+O3+cbxy5WCKaxq58oNt3L1kN7kV5ukcam30BiOP/3SAYB93/jGjr63NOS9GxAZxQa9gPtiQpXr/CiWztJ4AL1eCva3TYt4s4i+EmCGESBNCZAohHu/g9UeEEIeFEAeEEH8IIRTR06BV/C3t+dc1NfPL3kJmDwlX5izcc+RsCrmcnQRXJUWx7m+TeHhqb9anlTH19Q28uOwwNTZso30+fL41h5TCWp6bPaBtCJA98uCU3pTXa1XvX6FkltaREOZjtQyyTou/EMIZeBeYCfQHrhVCnFjyuBdIklIOBv4H/F9n1zUHgVbq7Pnz3kI0OoOi+vicL+dayOXl5sKDUxNY/9gkLk+M4JMt2Ux8dR2fbcmm2dD5zqGWJr9Sw2tr0pnaL4yZA7vb2pxOMTJO9f6VipSSjNJ6q8X7wTye/0ggU0qZJaXUAd8Cc9qfIKVcJ6XUtDzdDphvWG0n8PNwwdlJWFT8pZQs3pbLkEh/BkcGWGwda9CZQq5ufh7835VDWHb/OAaE+/Hcb4e56I2NrOlE51BLI6XkqV9ScBLwvBXHMlqSVu//651q3r+SyK9spFrTbLVMHzCP+EcA+e2eF7QcOxW3ASvNsG6nEUIQ6OVq0c6eO7IrySitt3uvv6axmbuW7O50IdeAcH+W3DaKT29OwknAgsW7mbdoOymF59Y51Br8dqCIDell/G16H8ID7Lcuoz0j44IYHR/EF1tzbG2KSjsWbTqKq7Ow6t2lVTd8hRA3AEnAK6d4fYEQIlkIkVxWVmYVmyzd2XPx9lz8PV25dIhtBraYA3NP5BJCcGHfbqx6aAIvzBlARkvn0Ee/309xTZOZrO4c1Rodz/92iCGR/tw4JtbW5piVMF8Phy/GsyeKa5r4flcBVw6PsqqTYQ7xLwTap7BEthw7DiHEVOBJYLaUUtvRG0kpF0kpk6SUSaGhoWYw7cwEeblZbMO3tK6J1SnFXDU8Eg9XZ4usYQ0sNZHL1dmJ+WNiWf/YJBZMiOe3/ceY9Oo6Xl+TRsNpOodag4UrjlClaWbh3MEWH6RtbUpqm+jm62FrM1Ra+HDjUQxScreVCwfNIf67gAQhRJwQwg2YByxtf4IQIhH4EJPwl5phTbMR4OVqsVTPlQeL0Rul3fbxAetM5PLzcOWJmf3449GJTO3Xjbf+zGTSq+v5btfJnUOtwbajFXyXnM8d4+PpH+5n9fUtTWmdljA/ZXYi7WqU1Wn5ekcelw2NIDrYy6prd1r8pZR64D5gNZAKfC+lPCSEeF4IMbvltFcAH+AHIcQ+IcTSU7yd1QnydqPSQhu+DS2dFCPsNF7cWsjVK8w6E7migrx457ph/Hj3WCIDPfnHj6bOoZszyi26bnuamg08+fNBooI8eXBKgtXWtRZSSpPn76d6/krg401ZNBuM3DvZ+u1CzDJmSUq5AlhxwrGn2z2eao51LEGAlxvVGh1SSofI5jAXxxVy3WDdiVzDYwL56e6xLD9YxL9XHuGGT3YwuU8o/7y4n8Unn723LpOs8ga+vHUknm72G6o7FfVaPRqdgW6q529zKht0LN6eyyWDw4m3QZPALl3hC6bOns0GedrpVF2R9oVctvjDFEJwyeDwts6hyTlVzHhzE0/9cpDy+g63jDpNRkkd7284yuWJEUzobZ09J2tTUmv6t1M9f9vz6eZsNDoD913Yyybrd3nxD7Biiwd7QUkTuTxcnblzYk/WPzaJ60dF883OfCa/sp731x81a+fQ1rGM3u4uPDWrn9neV2mU1pqyqcLUDV+bUtPYzBdbc5g5sDu9bTTHu8uLf5CVWjzYC0qdyBXs487zcway+qEJjIoP4j+rjjDltQ0s3X/MLEVi3+zKIzm3iqdm9SfYx3FDIiV1JvFXwz625fMtOdRp9Tbz+kEV/7bOnrYY5K40zFXIZUl6hfnw8U0j+Or2Ufh5uvLAN3u5/L2t7M49/86hJbVN/HvFEcb2DOaKYaerT7R/1LCP7alraubTLdlM7RfGgHB/m9mhvE+3lWl1Gpuald9nxpKYCrn2m62Qy9Jc0CuEZfeP4/+uHMyx6kaueH8b9361h7wKzZl/+ASe++0QOoORly9X/ljGzlJS24Svu4tVN/BVjmfx9lxqGpu5/0LbZpN1efH/PbUUFyfB6Hj769FuTkyFXCVmL+SyJM5OgqtbOoc+OCWBP4+UMvX1Dby8IpWaxrPbw1l7uIQVB4t5YEoCsSHeFrbY9pTWqjn+tkSj0/Pxpmwm9A5lSJRte311afGXUrLiYBFje4W0bfx2RaxRyGVJvN1deHhab9b9bRKzh4bz0aYsJr2yji+25py2c2i9Vs/Tv6bQp5svCybEW9Fi26DTG9mXX01UkHWLiVT+4usdeVQ26HjAhrH+Vrq0+B86VktepYaL7bxVb2doX8j17yvsO+zR3d+DV68awm/3jaNvdz+eWXqI6f/dyNrDJR1uCr+6Oo3i2iYWXjEIVwXub5ib75LzKaxutMsLvCPQ1Gxg0cYsxsQHk6SAaXCO/xd/GlamFOHsJLhoQNcU/xMLubzcHCMOPDDCn6/vGMXHNyaBhDu+TOa6j3Yc1zl0X341X2zLYf7oGIZFB9rOWCvR1GzgnT8zGBEbyEQHrWFQOt8n51Nap+X+Kbb3+qELi78p5FPMmPhggqw0Nk1p2LqQy5IIIZjavxurH57Ac7MHcKS4lkvf2czffthPQZWGx388QDdfD0Wls1qSJdtzKanV8uhFfez67s5e0emNfLD+KEkxgYyJD7a1OYCZ2jvYI0eK68gub+D28XG2NsUmKKmQy5K4Ojtx09hYLkuM4N11mXy+JYf/7S4A4L/XDMXXw37HMp4tDVo9760/yrheIYxWiPB0NX7cU8CxmiYWXjFYMRffLuv5rzhYhJOA6V0w5KPUQi5L4u/pyj8v7senN49oO/byilS+T863SedQa/LZlmwqG3Q8elFvW5vSJWk2GHlvfSaDI/2ZkBBia3Pa6JLiL6Vk+cEiRsUFE+LA1ZwdYQ+FXJZCSsmHG4/i4+7Cu9cNIzzAk7//7wCXvL2ZLZnW6xxqTWo0zXy4MYup/cJI7AJ7G0rk572F5Fc2cv+FCYrx+qGLin9GaT1ZZQ1cPMiyXn9oy4VlkxVbEp8OeyvkMje/7CtkU0Y5/5jRh1mDe/DzPWN569pEahubuf7jHdz2+S4yS+ttbaZZ+WhTFnVNeh6Z1jXu8JTGlsxynv41hSGR/kztF2Zrc46jS4r/8gNFCAHTLZzieVliBAlhPjy79BCNOvM1ITtfWgu5nrKjQi5zUdmg44VlqQyLDuD6UaZ5ykIIZg8J549HJ/KPGX3ZmV3J9P9u5OlfU6iwUOdQa1JRr+XTLdnMGtzDIYfSKJ2N6WXc+vkuYoK8+eTmEYry+qGLiv/KlCJGxAZZvLOhq7MTL142kMLqRt5Zl2HRtc5E+0Kum7pgnvdLy1OpbTSNZXQ6YSyjh6szd08ydQ69bmQ0X+3IY9Ir6/lwg3k7h1qb1s6nD09VY/3WZl1aKbd/mUx8qA/fLBityPCyWcRfCDFDCJEmhMgUQjzewesThBB7hBB6IcSV5ljzfMksrSO9pN5qhV2j4oOZOyyCRRuzbBZScKRCrvNhS2Y5P+4p4K6JPenT/dTtc4N93HnhsoGsfmg8I+KCWLjyCFNf38BvZuocak2Ka5pYvD2XyxMj6RXmWGm8SueP1BLu/HI3CWE+fH37KMWmknda/IUQzsC7wEygP3CtEKL/CaflATcDX3d2vc6y4mAxADMHWS+98Z8X98PT1Zl//ZJidRFx1EKus6Wp2cA/fz5IXIj3WbfP7RXmy6c3j2DJbaPwcXfh/m/2csX7W9mdW2Vha83HO+syMBglD011vFGUSmbNoWLuWrKbvj18+fr20QQqVPjBPJ7/SCBTSpklpdQB3wJz2p8gpcyRUh4AbN46c8XBIpJiAq3a0jbEx52/z+jLtqwKlu4/ZrV1wbELuc6Gt/7IILdCw0uXDcTD9dzGMo5LCGH5A+P5vysGk1/VyBXvb+W+r/eQX3nunUOtSX6lhu925XPNiCi1j48VWZVSxD1f7aF/uD+LbxuFv5eya0jMIf4RQH675wUtxxRHVlk9R4rruNiKXn8r146MZkikPy8sS6W2yTpTw7pKIdepSC2qZdHGLK4cHsnYXueXX+3sJLh6RBTr/zaJB6Yk8HtqCVNe28DCldb7fzxX3vwjAyGEzVsGdyWWHTjGvV/vZXCkP4tvG4m/p7KFHxS24SuEWCCESBZCJJeVlZn9/VemmEI+M2zQyM3ZSfDiZYOoaNDy+pp0i6/XFQu52mNoGcvo5+nKkxd3fiyjt7sLj7R0Dr10SDiLNmYx6ZX1fLnt9J1Drc3Rsnp+2lPA/NExdPdXB7ZYg1/3FfLAN3sZFh3Al7eNws9OqsbNIf6FQFS755Etx84ZKeUiKWWSlDIpNNT8zadWHCwiMTqA8ABPs7/32TAo0p/5o2P4clvOcU3GzE1XLuRqZcn2XPblV/P0Jf3NGnft4e/Ja1ebOof27ubD078eYsZ/N/JHasedQ63NG2vT27KXVCzPT3sKePi7fYyIDeLzW0biY0dDcsyhCruABCFEnBDCDZgHLDXD+5qV3IoGDh2rZZYNQj7tefSiPgR5u/HkLykYLdBWoKsXcgEU1TTyyuo0xieEMGdouEXWGBjhzzd3jGbR/OEYJdz2RTI3fLKDw8dqLbLe2ZBaVMuyA0XcckGsIlMLHY0fkvN59If9jI4P5rNbRtjddLROi7+UUg/cB6wGUoHvpZSHhBDPCyFmAwghRgghCoCrgA+FEIc6u+650prlY4uQT3v8PV15clY/9udX8+2u/DP/wDnSlQu5Wnnm10PojUZeusyyaa1CmNqBr35oAs9c2t/kXLy9icd+2E9JbZPF1j0Vr61Jx9fDhQXjVa/f0ny7M4+//3iAcb1C+OSmEXaZRWcWi6WUK4AVJxx7ut3jXZjCQTZjxcEihkQFEBlo++yHy4ZG8N2ufP6z6gjTB3Qj2Exe2pbMrl3IBbAqpZg1h0t4YmZfooOt83/t5uLELRfEMTcxknfWZfD51hyWHSjirok9uWNCnFWEYV9+Nb+nlvDotN6KzzKxd77akcuTP6cwsXcoH84ffs5ZZEqhSwSD8ys1HCysUczELiEEL142kAatniJlBnUAABjcSURBVH+vPGKW9zxW3cj933TdQi6A2qZmnlmaQv8eftw2zvqtuv29XHlyVn9+f2Qik/uG8sbv6Ux+dT3/211gkRBfe15bk0aQtxu32OD37kp8uS2HJ39O4cK+YSy60X6FH7qI+K9MKQKwSYrnqegV5ssdE+L5YXcBX2zNQd+JjBGt3sA9XbiQq5VXVqVRVqdl4dxBNt3kjgn25r3rh/PDXWPo7u/J337Yz6XvbGbrUcs0+NueVcGmjHLuntjTrjYc7Y1PNmfz9K+HmNa/G+/fMAx3F/sVfugi4r/8YDGDIvwVV/By/4W9GNszmGeWHmLWW5vZfJ7dP19Ydph9XbiQC2B3biVLduRy89g4hkQF2NocAEbEBvHz3WN5c95QqjXNXPfRDm7/IpmjZeZr8yGl5LU1aYT5ujN/TIzZ3lfleD7amMULyw4zY0B33r3O/oUfuoD4F1Rp2J9fzUwLt28+H7zcXPjq9lF8cMMwNM16bvhkB7d/sYuscxCHrl7IBaYReU/8dJAefh6KG1ji5CSYMzSCPx6dyN9n9GF7VgXT39jIs0sPUdmg6/T7b8woZ1dOFfdf2MuuQxBK5v31R3lpRSqzBvXg7esScXNxDNl0jN/iNKxqKey6WKHCKIRgxsAerH14Io/P7Mv2rEouemMjLyw7TI3m9BWkXb2Qq5VFG4+SXlLP83MGKjbdzsPVmXsm9WL9Y5O4ZkQUX27LYeIr61i08Sha/fl1Dm31+iMCPLlmRLR5DVYB4J0/M/jPqiPMHhLOm/OG4upANTOO85ucghUHi+jfw4/YEG9bm3JaPFyduWtiT9b9bRJXJUXy6ZZsJr26jsXbOt4PUAu5TGSV1fPWn5nMGtSDqf272dqcMxLi485Llw9i1UMTGB4TyMsrTJ1Dlx8oOucisTWHSzhQUMODUxMcxhtVCtUaHU/8dJBX16QzNzGCN64Z6nCfMcf6bU6gqKaRPXnVFp/YZU5Cfd1ZOHcwy+4fR5/uvvzr10PMfHMTG9P/anehFnKZkFLyz58P4u7ixDOXnthIVtn07ubL57eM5MtbR+Lt5sK9X+/hyg+2sTfv7DqHGoyS19ekEx/izdxERbbSskuMRsk3O/OY/Op6vtuVxx3j43jlqiE4Ozle9pwy75HNxMqWwi4lZfmcLQPCTRWkaw6X8PKKVG78dCcX9g3jyVn9WJVSzO+pJTx7af8uW8gF8MPuArZnVfLy5YMIs2KXVnMyoXcoF/QK4YfkfF5dk87l723l0iHh/H16n9MmKCw7cIy0kjreujbR4TxSW7E/v5qnf01hf0ENI2ODeG7OAPr1cNwJaEIJ/Ug6IikpSSYnJ3fqPa76YCt1TXpWPTTBTFbZBq3ewBdbc3j7j0zqtHoAJvYO5fNblDcazlqU12uZ+voGEsJ8+G7BmJOmc9kj9Vo9H244ykebsjBKuPWCOO6Z3POkRmF6g5Fpb2zE3cWJFQ+Md4jf3ZZUNuj4v1VH+C45nxAfd568uB9zhobb7WdLCLFbSpl0pvMc1mUoqW0iObeKmQrd6D0X3F2cWTChJ98sGN12bFtWBV9uy1VUR0lr8uKywzRo9SycO8hhxM/H3YVHL+rDn49O4pJBPfhgw1Emv7Kexdtzj9v3+WlPIdnlDTwyrbfD/O62wGCULN6e21aId/u4OP58dCKXJUbYrfCfCw4r/qtSipESZg22n3j/6dDqDTz1Swo+7i68d/0wkmICeWapaT9gfVqprc2zKhvSy/hl3zHumdSLXmGnHstor4QHePL6NUP57b5x9Arz4V+/pDDjzU2sO1KKVm/gzT8yGBLpzzQ72OBWKrtzq5j9zmb+9YupInzlg+N5clZ/fO2kHbM5cNiY/4qDRSSE+TiMOLy4LJV9+dV8cMMwZgzswcyB3fk9tZSXlh/m5s92MalPKE/N6ucwv++p0Oj0PPnzQeJDvblnsmM3MBsU6c+3C0z7Pv9eeYRbPt/V9trCuV2zhUdnKavT8u+VR/hxTwHd/Tx457pEZg3q0SX/LR3S8y+r07Izp9IuN3o74qc9BSzensudE/8q5BJCMK1/N9Y8PJGnZvVjd24V0/+7iWeXHqJa0/niIaXy5u8ZFFQ1svDyQQ5RZXkmhBBMb+kc+vcZf9VyLD9QRM3Hn0NsLP/f3p2HR1ndCxz//mYmk4UsQBZCAiEkhLC5gBRZSoUClqdXgd56XYqUerVUhNpqsY9Lb2ux3ra21mtVbN16heJ1wVqoG66IWLBCVRAQDGFpIJRAMZEkk8xMzv3jncAQEjMw78xkMr/P8+SZM++czPs7mcnvPee8Gw6H9bh8eazC7PJ8/hb+8M5uvnz3GlZ9uJ/5k0p5/QcXcNHZ8Tu3H65u2fN/eas15dMdkn/riVzjSrK56cJTT+RyuxxcM7GEr40s5J7XdrJ0/R6ee38/N0wtY/bYAd3qpJSP9tfyyLrdXDGmP+eXZMc6nKhyuxz0TrNuSnNWYRbNy5bhfuk+8DZZFfbuhXnzrPLs2TGKMvbqm3xU1tRTefgYuw4dY9fheipr6tl9+BgebwsTy3K4fcZwShP0MijBumXyf2lLNSW5PRjcJ74/4OATuTo7pC87PZmfzTqLOWOLueP5bdz+l20s27CXH100jMnleVGMOjJab8vYK83NzdPDvy1jPKqute4R8OcFEzB3fQNXa+Jv1dDAgQU3MmN3H1KSHKQkOa1Hl/NEOcnZyfKOXmtTx+WI2SGmLS2GA7WNVNbUs6vm2EmPB4Puo+AQ6N87jZKcHkwozWb8oGwml+clbE+/rW6X/H3+FjZUHmH2+QPi90Nevhxz661k7vsHT2Tm0LT4Z+RmTA3pV8vzM1h29Rje+PgQd76wnav+8B5fGpzLf/3bUMr6xO/+gP/96x627K/lvitGJuz16j0+P26XwzrhaH9Vu3X61tUwbVgfmrx+PD4/Hm8LHq+fhmYf/6q3yh6vH4/vRPlMrzbtcsjxDUOyy0mq+9QNR3KSkxSXk1T3qRuU5MBGJCXJSWrSqRubZJeTTxu8Vi8+KMG39uJbZaS4KM1NZ/ygbEpz0ynN7UFJbjoDstMSYmrwTNmS/EVkOnAv4AQeMcb8os3rycBS4DzgCHCZMWaPHetuy+V0cP7AbF76qJpbvjok/i5vvHw5zJuHNDQAUFhXA7feADk9Qh7OiwhThvZhYlkuyzbs5d7XdjL93reZfX4R3/1yWdydEVx1tIG7X9nB5PJcLjo7/qfyzpSn2U9q68XbioqsqZ42pKiIn//7WSG/pzEGr98ENhR+PM0tJ8re9jcWJ792on6Tt4XGwOvHNzY+a3nr7zWe4cambS++JCjJ56S747ejF0NhZ0YRcQIPANOAKuA9EVlljNkWVO1q4KgxZpCIXA78Ergs3HV3ZNFXyvn6g3/lD+/sYcHkQZFaTUSYW289nviPa2iA22477blct8vB1V8cyNdGFvI/r+1k+bv7WLp+LwVZKQzpm8nQvhkM7ZvJkPxMBub06JKnsBtj+PHKrRgDd8wakdD/5I1ePylJgamWO++05viDvytpadby0yAiuF2C2+U45WSySGi7sWlqsxFpbD55Y5OZ4tJefITY0S0eA1QYYyoBRORJYCYQnPxnArcHyiuA+0VETIROLz5vQC+mDMnj92/t4sqxA8hKjY9pgiafH/c/Oriv7759Z/y+vXu4WTxzBN8cN4DXtx9ie3Ud26s/Y+3OGnyBblhKkoPyPhkMybc2CkP6ZjI0PzN2UyzLl1sbvH37WJyRw87v3UK/XtNjE0sX0ehtOdHzb+0IBP5GFBVZib+L7+yN9sZGdcyO5F8IBGesKuD8juoYY3wiUgtkA5G5tRHwgwvL+epv3+bhtZUsioPLHR+q8/CdP27ivowc+tXVnFqhKPxL9g7KyzjpPIAmn5+KQ8fYXv0ZH1fXsf1gHa9u/ydPbTzxcRb2TGVIvjVCGNo3kyF9MyjOjswowRhDk68F37I/krZwPo7GRgToV1dD4d0/gvK8Lp/cIsnj9Z98zf7ZsxP676HC06UmxEVkHjAPoCjMZDesIJOLzyngsXd2M3d8cZee595c9Snzlm6ittHL4Vt+Qr87fhj2cD4UyS4nwwuyGF6QdXyZMYaaz5rYFhgdbK+u4+ODdazZWYM/MEpITXIyOD+DoYGNQlmedVRVQ7OfBq+fxmafVW62hvENzX4avW2X+QLLT17WYmDdgzeR3th4UqxyhlNf3YnH6yfVrVMfyh52JP/9QP+g5/0Cy9qrUyUiLiALa8fvSYwxDwEPgXVht3ADu2FqGS9uqWbJmgp+cvHwcN8uIlZ+sJ8frthMTnoyz84fz7CC6dC/Z8yG8yJCXmYKeZkpTAo6RNTjbR0lnNgovLz1IE++18E0VYBDrDuWpbqdpLmtozrS3E7S3C6y05MDZSepSS7r0e2k8K4OBoRhTH11B43BO3yVCpMdyf89oExEBmIl+cuBb7SpswqYC6wHLgHeiNR8f7CS3HQuGdWP5Rv2cc3EEgp7pkZ6lSFraTH8+pUdLFmzizHFvVly5Shy0gOjky44nE9JcjKiMIsRhSePEv5Z18SummM4HXIikbtdpCVZiTzZ5Tj9nbQdHMlix9RXPGv0+smMk/1XqusL+ywNY4wPWAisBrYDTxtjtorIYhGZEaj2KJAtIhXAjcDN4a43VNdPLQPgt699Eq1Vduozj5d5yzayZM0urhhTxB+vOf9E4o8jIkJ+VgoTBuUwtiSbs/v1ZFBeBoU9U+nVw01KkvPMjs65805rqitYhKa+4onHqz1/ZR9b5vyNMS8CL7ZZ9uOgsgf4DzvWdboKe6Yye2wRS9fvZd4FJTE/rXvP4Xq+vXQjlYfruWPmcK4cG8cno0VKnB7JEmkeb4vepF3Zpvtc+OVzXDdpEMkuB/e8ujOmcbxTcZiZD7xDzbEmlv3nGOaMK9bE35HZs2HPHmhpsR4TPPGDNe2T6k6If1kVBQnxTcrNSOaqCcU8v7mabQfqor5+f4vh0XW7+eZjfyM/M4VVC77I+EE5UY9DxbfGZj8peqKTsklCJH+AeRNLyUxxcfcrO6K2Tp+/hT/9vYpp97zFHc9vY3J5Hs9eN56i7I7vzapUe4yxzorVQz2VXbrUcf6RlJWWxHcuKOVXq3ewofIIYyN4SWCvv4Xn3t/PA29WsPdIA0PyM1gyexTTh+frbffUGWnytWAMOuevbJMwyR/gqgnFLFu/lzmPvstVEway8MuDbD3FvNnXwrN/r+KBNyuoOtrIiMJMHppzHlOH9tGkr8Li8foB9GgfZZuESv5pbhervjuBX6/ewcNvV/LspioWfaWcS0f3D+tyBU0+P09vrOLBNys4UOvhnP49WTxzuF47XNmmMZD8teev7JJQyR8gLyOFuy45hzlji/npX7Zyy5+2sHT9Xn580TDGlZ7eVJDH6+fJv+3jd29VcrDOw6iinvz862fzpbIcTfrKVq3Xr9ejfZRdEi75tzqrXxbPXDuO5zdX84uXPuaKhzcwfXg+t351aKc7ZBuafTzx7j5+v7aSms+aGFPcm7svPYfxpdma9FVENDbrtI+yV8Imf7DOUL34nAKmDevDQ2sreXDNLt74+BBXTxzIgsmDSE8++c9T3+Rj2Ya9PLy2kiP1zYwvzea+K0ZGdOexUqDTPsp+CZ38W6UkObl+ShmXju7PXS9/zINrdrFiUxU3faWcS0b1o77Zx9L1e3nk7UqONniZWJbD9VPK+EJx71iHrhKER5O/spkm/yD5WSn85rJzmTNuAIuf38YPV2zmsXW7qa71UNvoZXJ5Lt+dUsaool6xDlWF6bF1u+nXK5ULh+fHOpSQ6NE+ym6a/NsxsqgXz147nlUfHuCBNyv4QnFvrp8yiLP79Yx1aMoGPn8LKz/Yz4dVtcw6t4CfXDycXj3csQ7rc7VO++hJXsoumvw74HAIs0YWMmtkYaxDUTZzOR08c+14lqyp4P43KlhXcYT//tqILj0K0B2+ym563JhKSG6Xg+9PHczKhRPIzUhm3rJNfO/J9zla3xzr0NrVOu2TnKT/ssoe+k1SCW14QRYrF0zg+1PLeGFzNdPuWcsrWw/GOqxTHD/OX3v+yiaa/FXCi4dRgB7qqewWVvIXkd4i8qqIfBJ4bPcwGBF5WUQ+FZHnw1mfUpE0vCCLVQtPHgWs7iKjgEavnySnkOTU/pqyR7jfpJuB140xZcDrdHx7xl8Bc8Jcl1IRl+S0RgGrFn6RvIxkvtNFRgF6LX9lt3CT/0zg8UD5cWBWe5WMMa8Dn4W5LqWiZlhBJisXTuCGqYO7xCigyecnRQ/zVDYKN/n3McZUB8oHgT5hvp9SXUaS08H3ppadNAq4/v+iPwowxlBd69GdvcpWnSZ/EXlNRD5q52dmcD1jjAFMOMGIyDwR2SgiG2tqasJ5K6VsEzwKeHFLNdPueYuXP4rOKMDj9fP9pz5gzY4apgzNi8o6VWIQK2ef4S+L7AAmGWOqRaQvsMYYU95B3UnAImPMRaG89+jRo83GjRvPODalImHbgTpuWvEhWw/UMeOcAm6fMZzeETo7+GCth3nLNrJlfy2LLiznukmletVY1SkR2WSMGd1ZvXCnfVYBcwPlucDKMN9PqS5tWEEmf14wgRunDealj6q5MEKjgPf3HeXi+9ex69AxHpozmgWTB2niV7YKt+efDTwNFAF7gUuNMf8SkdHAtcaYawL13gaGAOnAEeBqY8zqz3tv7fmrrm57dR2LnrFGAUPyM+iV5qZHsov0ZCfpKS6r7A48JluPPZKdx8vpQcvdrhP9sGc3VXHLc1vIz0zhkbmjGdwnI4atVPEm1J5/WMk/kjT5q3jg9bfwyNu72VB5hPomH8eafNQ3+6hv8nOsyUezryWk93E7HfRIdpLmdrH/00bGlWSzZPaoLn/BOdX1hJr89cJuSoUhyelg/qRS5k8qbfd1r7/lxEahyc+xJi/HmvxBy3yBsv94uTinB/MnleoJXSqiNPkrFUFJTgc909z0TNMevOpatGuhlFIJSJO/UkolIE3+SimVgDT5K6VUAtLkr5RSCUiTv1JKJSBN/koplYA0+SulVALqspd3EJEarOsFnakc4LBN4cSLRGtzorUXtM2JIpw2DzDG5HZWqcsm/3CJyMZQrm/RnSRamxOtvaBtThTRaLNO+yilVALS5K+UUgmoOyf/h2IdQAwkWpsTrb2gbU4UEW9zt53zV0op1bHu3PNXSinVgW6T/EWkt4i8KiKfBB57fU7dTBGpEpH7oxmj3UJps4icKyLrRWSriGwWkctiEWs4RGS6iOwQkQoRubmd15NF5KnA6++KSHH0o7RXCG2+UUS2BT7T10VkQCzitFNnbQ6q93URMYHbxca1UNosIpcGPuutIvKEbSs3xnSLH+Au4OZA+Wbgl59T917gCeD+WMcd6TYDg4GyQLkAqAZ6xjr202ijE9gFlABu4ENgWJs61wG/C5QvB56KddxRaPNkIC1Qnp8IbQ7UywDWAhuA0bGOOwqfcxnwPtAr8DzPrvV3m54/MBN4PFB+HJjVXiUROQ/oA7wSpbgiqdM2G2N2GmM+CZQPAIeATk8A6ULGABXGmEpjTDPwJFa7gwX/HVYAU0REohij3TptszHmTWNMQ+DpBqBflGO0WyifM8AdwC8BTzSDi5BQ2vxt4AFjzFEAY8whu1benZJ/H2NMdaB8ECvBn0REHMDdwKJoBhZBnbY5mIiMweph7Ip0YDYqBP4R9LwqsKzdOsYYH1ALZEclusgIpc3BrgZeimhEkddpm0VkFNDfGPNCNAOLoFA+58HAYBF5R0Q2iMh0u1YeV/fwFZHXgPx2Xrot+IkxxohIe4cxXQe8aIypipeOoQ1tbn2fvsAyYK4xpsXeKFWsiMiVwGjggljHEkmBjttvgG/FOJRoc2FN/UzCGt2tFZGzjDGf2vHGccMYM7Wj10TknyLS1xhTHUh07Q2PxgETReQ6IB1wi8gxY0yHO5dizYY2IyKZwAvAbcaYDREKNVL2A/2DnvcLLGuvTpWIuIAs4Eh0wouIUNqMiEzF6gRcYIxpilJskdJZmzOAEcCaQMctH1glIjOMMRujFqW9Qvmcq4B3jTFeYLeI7MTaGLwX7sq707TPKmBuoDwXWNm2gjFmtjGmyBhTjDX1s7QrJ/4QdNpmEXEDz2G1dUUUY7PLe0CZiAwMtOVyrHYHC/47XAK8YQJ7x+JUp20WkZHA74EZds4Dx9DnttkYU2uMyTHGFAf+fzdgtT1eEz+E9t3+M1avHxHJwZoGqrRj5d0p+f8CmCYinwBTA88RkdEi8khMI4ucUNp8KfAl4Fsi8kHg59zYhHv6AnP4C4HVwHbgaWPMVhFZLCIzAtUeBbJFpAK4EevIp7gVYpt/hTV6fSbwmbZNGnElxDZ3KyG2eTVwRES2AW8CNxljbBnV6hm+SimVgLpTz18ppVSINPkrpVQC0uSvlFIJSJO/UkolIE3+SimVgDT5K6VUAtLkr5RSCUiTv1JKJaD/BzDuR3487/B5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0adc82ad90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# (Load code from previous cell -- make sure to have executed above cell first.)\n",
    "%run -i _derived/1_json_to_stroke.py\n",
    "\n",
    "# Visualize / control output of json_to_stroke().\n",
    "\n",
    "stroke = json_to_stroke(sample[3])\n",
    "# First 2 dimensions are normalized dx/dy coordinates\n",
    "# third dimension indicates \"new stroke\".\n",
    "xy = stroke[:2, :].cumsum(axis=1)\n",
    "pyplot.plot(*xy)\n",
    "pxy = xy[:, stroke[2] != 0]\n",
    "pyplot.plot(pxy[0], pxy[1], 'ro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting _derived/1_make_example_stroke.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile _derived/1_make_example_stroke.py\n",
    "# (Written into separate file for sharing between notebooks.)\n",
    "\n",
    "# Convert drawing tf.train.Example proto.\n",
    "# Uses json_to_stroke() from previous cell to create raster image.\n",
    "\n",
    "def make_example_stroke(label, drawing):\n",
    "    example = tf.train.Example()\n",
    "    example.features.feature['label'].int64_list.value.append(label)\n",
    "    stroke = json_to_stroke(drawing)\n",
    "    example.features.feature['stroke_x'].float_list.value.extend(stroke[0, :])\n",
    "    example.features.feature['stroke_y'].float_list.value.extend(stroke[1, :])\n",
    "    example.features.feature['stroke_z'].float_list.value.extend(stroke[2, :])\n",
    "    example.features.feature['stroke_len'].int64_list.value.append(stroke.shape[1])\n",
    "    example.features.feature['countrycode'].bytes_list.value.append(drawing['countrycode'].encode())\n",
    "    example.features.feature['recognized'].int64_list.value.append(drawing['recognized'])\n",
    "    example.features.feature['word'].bytes_list.value.append(drawing['word'].encode())\n",
    "    ts = drawing['timestamp']\n",
    "    ts = time.mktime(time.strptime(ts[:ts.index('.')], '%Y-%m-%d %H:%M:%S'))\n",
    "    example.features.feature['timestamp'].int64_list.value.append(long(ts))\n",
    "    example.features.feature['key_id'].int64_list.value.append(long(drawing['key_id']))\n",
    "    return example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processed 2047/70000 (2.92%)\n",
      "processed 4381/70000 (6.26%)\n",
      "processed 6655/70000 (9.51%)\n",
      "processed 8840/70000 (12.63%)\n",
      "processed 10913/70000 (15.59%)\n",
      "processed 13184/70000 (18.83%)\n",
      "processed 15391/70000 (21.99%)\n",
      "processed 17677/70000 (25.25%)\n",
      "processed 19939/70000 (28.48%)\n",
      "processed 22255/70000 (31.79%)\n",
      "processed 24515/70000 (35.02%)\n",
      "processed 26726/70000 (38.18%)\n",
      "processed 28894/70000 (41.28%)\n",
      "processed 30940/70000 (44.20%)\n",
      "processed 33007/70000 (47.15%)\n",
      "processed 35298/70000 (50.43%)\n",
      "processed 37525/70000 (53.61%)\n",
      "processed 39659/70000 (56.66%)\n",
      "processed 41966/70000 (59.95%)\n",
      "processed 44306/70000 (63.29%)\n",
      "processed 46634/70000 (66.62%)\n",
      "processed 48664/70000 (69.52%)\n",
      "processed 50801/70000 (72.57%)\n",
      "processed 52929/70000 (75.61%)\n",
      "processed 54648/70000 (78.07%)\n",
      "processed 56763/70000 (81.09%)\n",
      "processed 58827/70000 (84.04%)\n",
      "processed 60914/70000 (87.02%)\n",
      "processed 63059/70000 (90.08%)\n",
      "processed 65194/70000 (93.13%)\n",
      "processed 67279/70000 (96.11%)\n",
      "processed 69398/70000 (99.14%)\n",
      "stored examples to \"../data/dataset_stroke\"\n",
      "generated 700000 examples in 323 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0adccce850>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# (Load code from previous cell -- make sure to have executed above cell first.)\n",
    "%run -i _derived/1_make_example_stroke.py\n",
    "\n",
    "# Create the (stroke) dataset.\n",
    "\n",
    "path = '%s/dataset_stroke' % data_path\n",
    "t0 = time.time()\n",
    "n = make_sharded_files(\n",
    "    make_example=make_example_stroke,\n",
    "    path=path,\n",
    "    classes=classes,\n",
    "    iters=[loaditer(name) for name in classes],\n",
    "    splits=dict(train=50000, eval=10000, test=10000),\n",
    "    overwrite=True,\n",
    ")\n",
    "\n",
    "print 'stored examples to \"%s\"' % path\n",
    "print 'generated %d examples in %d seconds' % (n, time.time() - t0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
